From 3913bd25be8c61379f06003f9d2bb44cc0caf178 Mon Sep 17 00:00:00 2001 From: atheesh Date: Mon, 17 Aug 2020 20:29:59 +0530 Subject: [PATCH 01/27] swagger gen command added --- scripts/protocgen.sh | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/scripts/protocgen.sh b/scripts/protocgen.sh index e26cfdcee661..4f6730bc9665 100755 --- a/scripts/protocgen.sh +++ b/scripts/protocgen.sh @@ -2,6 +2,8 @@ set -eo pipefail +proto_files='' + proto_dirs=$(find ./proto -path -prune -o -name '*.proto' -print0 | xargs -0 -n1 dirname | sort | uniq) for dir in $proto_dirs; do protoc \ @@ -17,8 +19,17 @@ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. \ -I "third_party/proto" \ --grpc-gateway_out=logtostderr=true:. \ $(find "${dir}" -maxdepth 1 -name '*.proto') + + proto_files=${proto_files}" ${dir:2}/*.proto" done +echo $proto_files + +protoc ${proto_files} \ +-I "proto" \ +-I "third_party/proto" \ +--swagger_out=allow_merge=true,logtostderr=true:. + # generate codec/testdata proto code protoc -I "proto" -I "third_party/proto" -I "testutil/testdata" --gocosmos_out=plugins=interfacetype+grpc,\ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. ./testutil/testdata/proto.proto From 2bbfd2ee575669b47d24172141a805bf13cab041 Mon Sep 17 00:00:00 2001 From: atheesh Date: Mon, 17 Aug 2020 22:14:38 +0530 Subject: [PATCH 02/27] proto file changed --- scripts/protocgen.sh | 2 -- 1 file changed, 2 deletions(-) diff --git a/scripts/protocgen.sh b/scripts/protocgen.sh index 4f6730bc9665..1ca660067a4e 100755 --- a/scripts/protocgen.sh +++ b/scripts/protocgen.sh @@ -23,8 +23,6 @@ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. \ proto_files=${proto_files}" ${dir:2}/*.proto" done -echo $proto_files - protoc ${proto_files} \ -I "proto" \ -I "third_party/proto" \ From 1bcdd34a32dc1502124855333a6b1e4695ae2057 Mon Sep 17 00:00:00 2001 From: anilCSE Date: Thu, 20 Aug 2020 19:43:32 +0530 Subject: [PATCH 03/27] Add filter for swagger files --- scripts/protocgen.sh | 19 +- x/auth/v1beta1/query.swagger.json | 155 +++ x/bank/v1beta1/query.swagger.json | 377 ++++++ x/distribution/v1beta1/query.swagger.json | 628 ++++++++++ x/evidence/v1beta1/query.swagger.json | 214 ++++ x/gov/v1beta1/query.swagger.json | 785 ++++++++++++ x/ibc/channel/query.swagger.json | 982 +++++++++++++++ x/ibc/connection/query.swagger.json | 520 ++++++++ x/ibc/transfer/query.swagger.json | 273 ++++ x/mint/v1beta1/query.swagger.json | 182 +++ x/params/v1beta1/query.swagger.json | 114 ++ x/slashing/v1beta1/query.swagger.json | 302 +++++ x/staking/types/staking.pb.go | 1128 ++++++++--------- x/staking/v1beta1/query.swagger.json | 1385 +++++++++++++++++++++ x/upgrade/v1beta1/query.swagger.json | 150 +++ 15 files changed, 6647 insertions(+), 567 deletions(-) create mode 100644 x/auth/v1beta1/query.swagger.json create mode 100644 x/bank/v1beta1/query.swagger.json create mode 100644 x/distribution/v1beta1/query.swagger.json create mode 100644 x/evidence/v1beta1/query.swagger.json create mode 100644 x/gov/v1beta1/query.swagger.json create mode 100644 x/ibc/channel/query.swagger.json create mode 100644 x/ibc/connection/query.swagger.json create mode 100644 x/ibc/transfer/query.swagger.json create mode 100644 x/mint/v1beta1/query.swagger.json create mode 100644 x/params/v1beta1/query.swagger.json create mode 100644 x/slashing/v1beta1/query.swagger.json create mode 100644 x/staking/v1beta1/query.swagger.json create mode 100644 x/upgrade/v1beta1/query.swagger.json diff --git a/scripts/protocgen.sh b/scripts/protocgen.sh index 1ca660067a4e..377bdb7d633e 100755 --- a/scripts/protocgen.sh +++ b/scripts/protocgen.sh @@ -23,10 +23,17 @@ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. \ proto_files=${proto_files}" ${dir:2}/*.proto" done -protoc ${proto_files} \ --I "proto" \ --I "third_party/proto" \ ---swagger_out=allow_merge=true,logtostderr=true:. +proto_dirs=$(find ./proto -path -prune -o -name '*.proto' -print0 | xargs -0 -n1 dirname | sort | uniq) +for dir in $proto_dirs; do + query_file=$(find "${dir}" -maxdepth 1 -name 'query.proto') + if [[ ! -z "$query_file" ]]; then + protoc \ + -I "proto" \ + -I "third_party/proto" \ + "$query_file" \ + --swagger_out=logtostderr=true:. + fi +done # generate codec/testdata proto code protoc -I "proto" -I "third_party/proto" -I "testutil/testdata" --gocosmos_out=plugins=interfacetype+grpc,\ @@ -34,6 +41,10 @@ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. ./testutil # move proto files to the right places cp -r github.com/cosmos/cosmos-sdk/* ./ +cp -r cosmos/* ./x/ +cp -r ibc/* ./x/ibc/ rm -rf github.com +rm -rf cosmos +rm -rf ibc diff --git a/x/auth/v1beta1/query.swagger.json b/x/auth/v1beta1/query.swagger.json new file mode 100644 index 000000000000..3c80da300bfe --- /dev/null +++ b/x/auth/v1beta1/query.swagger.json @@ -0,0 +1,155 @@ +{ + "swagger": "2.0", + "info": { + "title": "cosmos/auth/v1beta1/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/cosmos/auth/v1beta1/accounts/{address}": { + "get": { + "summary": "Account returns account details based on address.", + "operationId": "Query_Account", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryAccountResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "address", + "description": "address defines the address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/auth/v1beta1/params": { + "get": { + "summary": "Params queries all parameters.", + "operationId": "Query_Params", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryParamsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "protobufAny": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := \u0026pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "runtimeError": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/protobufAny" + } + } + } + }, + "v1beta1Params": { + "type": "object", + "properties": { + "max_memo_characters": { + "type": "string", + "format": "uint64" + }, + "tx_sig_limit": { + "type": "string", + "format": "uint64" + }, + "tx_size_cost_per_byte": { + "type": "string", + "format": "uint64" + }, + "sig_verify_cost_ed25519": { + "type": "string", + "format": "uint64" + }, + "sig_verify_cost_secp256k1": { + "type": "string", + "format": "uint64" + } + }, + "description": "Params defines the parameters for the auth module." + }, + "v1beta1QueryAccountResponse": { + "type": "object", + "properties": { + "account": { + "$ref": "#/definitions/protobufAny", + "description": "account defines the account of the corresponding address." + } + }, + "description": "QueryAccountResponse is the response type for the Query/Account RPC method." + }, + "v1beta1QueryParamsResponse": { + "type": "object", + "properties": { + "params": { + "$ref": "#/definitions/v1beta1Params", + "description": "params defines the parameters of the module." + } + }, + "description": "QueryParamsResponse is the response type for the Query/Params RPC method." + } + } +} diff --git a/x/bank/v1beta1/query.swagger.json b/x/bank/v1beta1/query.swagger.json new file mode 100644 index 000000000000..904f88d9b2ed --- /dev/null +++ b/x/bank/v1beta1/query.swagger.json @@ -0,0 +1,377 @@ +{ + "swagger": "2.0", + "info": { + "title": "cosmos/bank/v1beta1/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/cosmos/bank/v1beta1/balances/{address}": { + "get": { + "summary": "AllBalances queries the balance of all coins for a single account.", + "operationId": "Query_AllBalances", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryAllBalancesResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "address", + "description": "address is the address to query balances for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/bank/v1beta1/balances/{address}/{denom}": { + "get": { + "summary": "Balance queries the balance of a single coin for a single account.", + "operationId": "Query_Balance", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryBalanceResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "address", + "description": "address is the address to query balances for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "denom", + "description": "denom is the coin denom to query balances for.", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/bank/v1beta1/params": { + "get": { + "summary": "Params queries the parameters of x/bank module.", + "operationId": "Query_Params", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryParamsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/bank/v1beta1/supply": { + "get": { + "summary": "TotalSupply queries the total supply of all coins.", + "operationId": "Query_TotalSupply", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryTotalSupplyResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/bank/v1beta1/supply/{denom}": { + "get": { + "summary": "SupplyOf queries the supply of a single coin.", + "operationId": "Query_SupplyOf", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QuerySupplyOfResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "denom", + "description": "denom is the coin denom to query balances for.", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "protobufAny": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + }, + "runtimeError": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/protobufAny" + } + } + } + }, + "v1beta1Coin": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + }, + "v1beta1PageRequest": { + "type": "object", + "properties": { + "key": { + "type": "string", + "format": "byte", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." + }, + "offset": { + "type": "string", + "format": "uint64", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." + }, + "limit": { + "type": "string", + "format": "uint64", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." + }, + "count_total": { + "type": "boolean", + "format": "boolean", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." + } + }, + "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", + "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" + }, + "v1beta1PageResponse": { + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + }, + "v1beta1Params": { + "type": "object", + "properties": { + "send_enabled": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1SendEnabled" + } + }, + "default_send_enabled": { + "type": "boolean", + "format": "boolean" + } + }, + "description": "Params defines the set of bank parameters." + }, + "v1beta1QueryAllBalancesResponse": { + "type": "object", + "properties": { + "balances": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1Coin" + }, + "description": "balances is the balances of all the coins." + }, + "pagination": { + "$ref": "#/definitions/v1beta1PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryAllBalancesResponse is the response type for the Query/AllBalances RPC method." + }, + "v1beta1QueryBalanceResponse": { + "type": "object", + "properties": { + "balance": { + "$ref": "#/definitions/v1beta1Coin", + "description": "balance is the balance of the coin." + } + }, + "description": "QueryBalanceResponse is the response type for the Query/Balance RPC method." + }, + "v1beta1QueryParamsResponse": { + "type": "object", + "properties": { + "params": { + "$ref": "#/definitions/v1beta1Params" + } + }, + "description": "QueryParamsResponse defines the response type for querying x/bank parameters." + }, + "v1beta1QuerySupplyOfResponse": { + "type": "object", + "properties": { + "amount": { + "$ref": "#/definitions/v1beta1Coin", + "description": "amount is the supply of the coin." + } + }, + "description": "QuerySupplyOfResponse is the response type for the Query/SupplyOf RPC method." + }, + "v1beta1QueryTotalSupplyResponse": { + "type": "object", + "properties": { + "supply": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1Coin" + }, + "title": "supply is the supply of the coins" + } + }, + "title": "QueryTotalSupplyResponse is the response type for the Query/TotalSupply RPC method" + }, + "v1beta1SendEnabled": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "enabled": { + "type": "boolean", + "format": "boolean" + } + }, + "title": "Send enabled configuration properties for each denomination" + } + } +} diff --git a/x/distribution/v1beta1/query.swagger.json b/x/distribution/v1beta1/query.swagger.json new file mode 100644 index 000000000000..b12a15e567f6 --- /dev/null +++ b/x/distribution/v1beta1/query.swagger.json @@ -0,0 +1,628 @@ +{ + "swagger": "2.0", + "info": { + "title": "cosmos/distribution/v1beta1/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/cosmos/distribution/v1beta1/community_pool": { + "get": { + "summary": "CommunityPool queries the community pool coins.", + "operationId": "Query_CommunityPool", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryCommunityPoolResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards": { + "get": { + "summary": "DelegationTotalRewards queries the total rewards accrued by a each validator.", + "operationId": "Query_DelegationTotalRewards", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryDelegationTotalRewardsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "delegator_address", + "description": "delegator_address defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards/{validator_address}": { + "get": { + "summary": "DelegationRewards queries the total rewards accrued by a delegation.", + "operationId": "Query_DelegationRewards", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryDelegationRewardsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "delegator_address", + "description": "delegator_address defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "validator_address", + "description": "validator_address defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/delegators/{delegator_address}/validators": { + "get": { + "summary": "DelegatorValidators queries the validators of a delegator.", + "operationId": "Query_DelegatorValidators", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryDelegatorValidatorsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "delegator_address", + "description": "delegator_address defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/delegators/{delegator_address}/withdraw_address": { + "get": { + "summary": "DelegatorWithdrawAddress queries withdraw address of a delegator.", + "operationId": "Query_DelegatorWithdrawAddress", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryDelegatorWithdrawAddressResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "delegator_address", + "description": "delegator_address defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/params": { + "get": { + "summary": "Params queries params of the distribution module.", + "operationId": "Query_Params", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryParamsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/validators/{validator_address}/commission": { + "get": { + "summary": "ValidatorCommission queries accumulated commission for a validator.", + "operationId": "Query_ValidatorCommission", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryValidatorCommissionResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "validator_address", + "description": "validator_address defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/validators/{validator_address}/outstanding_rewards": { + "get": { + "summary": "ValidatorOutstandingRewards queries rewards of a validator address.", + "operationId": "Query_ValidatorOutstandingRewards", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryValidatorOutstandingRewardsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "validator_address", + "description": "validator_address defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/validators/{validator_address}/slashes": { + "get": { + "summary": "ValidatorSlashes queries slash events of a validator.", + "operationId": "Query_ValidatorSlashes", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryValidatorSlashesResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "validator_address", + "description": "validator_address defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "starting_height", + "description": "starting_height defines the optional starting height to query the slashes.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "ending_height", + "description": "starting_height defines the optional ending height to query the slashes.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "protobufAny": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + }, + "runtimeError": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/protobufAny" + } + } + } + }, + "v1beta1DecCoin": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "DecCoin defines a token with a denomination and a decimal amount.\n\nNOTE: The amount field is an Dec which implements the custom method\nsignatures required by gogoproto." + }, + "v1beta1DelegationDelegatorReward": { + "type": "object", + "properties": { + "validator_address": { + "type": "string", + "format": "byte" + }, + "reward": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1DecCoin" + } + } + }, + "description": "DelegationDelegatorReward defines the properties\nof a delegator's delegation reward." + }, + "v1beta1PageRequest": { + "type": "object", + "properties": { + "key": { + "type": "string", + "format": "byte", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." + }, + "offset": { + "type": "string", + "format": "uint64", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." + }, + "limit": { + "type": "string", + "format": "uint64", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." + }, + "count_total": { + "type": "boolean", + "format": "boolean", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." + } + }, + "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", + "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" + }, + "v1beta1PageResponse": { + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + }, + "v1beta1Params": { + "type": "object", + "properties": { + "community_tax": { + "type": "string" + }, + "base_proposer_reward": { + "type": "string" + }, + "bonus_proposer_reward": { + "type": "string" + }, + "withdraw_addr_enabled": { + "type": "boolean", + "format": "boolean" + } + }, + "description": "Params defines the set of distribution parameters." + }, + "v1beta1QueryCommunityPoolResponse": { + "type": "object", + "properties": { + "pool": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1DecCoin" + }, + "description": "pool defines community pool's coins." + } + }, + "description": "QueryCommunityPoolResponse is the response type for the Query/CommunityPool RPC method." + }, + "v1beta1QueryDelegationRewardsResponse": { + "type": "object", + "properties": { + "rewards": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1DecCoin" + }, + "description": "rewards defines the rewards accrued by a delegation." + } + }, + "description": "QueryDelegationRewardsResponse is the response type for the Query/DelegationRewards RPC method." + }, + "v1beta1QueryDelegationTotalRewardsResponse": { + "type": "object", + "properties": { + "rewards": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1DelegationDelegatorReward" + }, + "description": "rewards defines all the rewards accrued by a delegator." + }, + "total": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1DecCoin" + }, + "description": "total defines the sum of all the rewards." + } + }, + "description": "QueryDelegationTotalRewardsResponse is the response type for the Query/DelegationTotalRewards RPC method." + }, + "v1beta1QueryDelegatorValidatorsResponse": { + "type": "object", + "properties": { + "validators": { + "type": "array", + "items": { + "type": "string", + "format": "byte" + }, + "description": "validators defines the validators a delegator is delegating for." + } + }, + "description": "QueryDelegatorValidatorsResponse is the response type for the Query/DelegatorValidators RPC method." + }, + "v1beta1QueryDelegatorWithdrawAddressResponse": { + "type": "object", + "properties": { + "withdraw_address": { + "type": "string", + "format": "byte", + "description": "withdraw_address defines the delegator address to query for." + } + }, + "description": "QueryDelegatorWithdrawAddressResponse is the response type for the Query/DelegatorWithdrawAddress RPC method." + }, + "v1beta1QueryParamsResponse": { + "type": "object", + "properties": { + "params": { + "$ref": "#/definitions/v1beta1Params", + "description": "params defines the parameters of the module." + } + }, + "description": "QueryParamsResponse is the response type for the Query/Params RPC method." + }, + "v1beta1QueryValidatorCommissionResponse": { + "type": "object", + "properties": { + "commission": { + "$ref": "#/definitions/v1beta1ValidatorAccumulatedCommission", + "description": "commission defines the commision the validator received." + } + }, + "title": "QueryValidatorCommissionResponse is the response type for the Query/ValidatorCommission RPC method" + }, + "v1beta1QueryValidatorOutstandingRewardsResponse": { + "type": "object", + "properties": { + "rewards": { + "$ref": "#/definitions/v1beta1ValidatorOutstandingRewards" + } + }, + "description": "QueryValidatorOutstandingRewardsResponse is the response type for the Query/ValidatorOutstandingRewards RPC method." + }, + "v1beta1QueryValidatorSlashesResponse": { + "type": "object", + "properties": { + "slashes": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1ValidatorSlashEvent" + }, + "description": "slashes defines the slashes the validator received." + }, + "pagination": { + "$ref": "#/definitions/v1beta1PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryValidatorSlashesResponse is the response type for the Query/ValidatorSlashes RPC method." + }, + "v1beta1ValidatorAccumulatedCommission": { + "type": "object", + "properties": { + "commission": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1DecCoin" + } + } + }, + "title": "accumulated commission for a validator\nkept as a running counter, can be withdrawn at any time" + }, + "v1beta1ValidatorOutstandingRewards": { + "type": "object", + "properties": { + "rewards": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1DecCoin" + } + } + }, + "title": "outstanding (un-withdrawn) rewards for a validator\ninexpensive to track, allows simple sanity checks" + }, + "v1beta1ValidatorSlashEvent": { + "type": "object", + "properties": { + "validator_period": { + "type": "string", + "format": "uint64" + }, + "fraction": { + "type": "string" + } + }, + "title": "validator slash event\nheight is implicit within the store key\nneeded to calculate appropriate amounts of staking token\nfor delegations which withdraw after a slash has occurred" + } + } +} diff --git a/x/evidence/v1beta1/query.swagger.json b/x/evidence/v1beta1/query.swagger.json new file mode 100644 index 000000000000..688cdcd1229e --- /dev/null +++ b/x/evidence/v1beta1/query.swagger.json @@ -0,0 +1,214 @@ +{ + "swagger": "2.0", + "info": { + "title": "cosmos/evidence/v1beta1/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/cosmos/evidence/v1beta1/evidence": { + "get": { + "summary": "AllEvidence queries all evidence.", + "operationId": "Query_AllEvidence", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryAllEvidenceResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/evidence/v1beta1/evidence/{evidence_hash}": { + "get": { + "summary": "Evidence queries evidence based on evidence hash.", + "operationId": "Query_Evidence", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryEvidenceResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "evidence_hash", + "description": "evidence_hash defines the hash of the requested evidence.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "protobufAny": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := \u0026pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "runtimeError": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/protobufAny" + } + } + } + }, + "v1beta1PageRequest": { + "type": "object", + "properties": { + "key": { + "type": "string", + "format": "byte", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." + }, + "offset": { + "type": "string", + "format": "uint64", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." + }, + "limit": { + "type": "string", + "format": "uint64", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." + }, + "count_total": { + "type": "boolean", + "format": "boolean", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." + } + }, + "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", + "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" + }, + "v1beta1PageResponse": { + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + }, + "v1beta1QueryAllEvidenceResponse": { + "type": "object", + "properties": { + "evidence": { + "type": "array", + "items": { + "$ref": "#/definitions/protobufAny" + }, + "description": "evidence returns all evidences." + }, + "pagination": { + "$ref": "#/definitions/v1beta1PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryAllEvidenceResponse is the response type for the Query/AllEvidence RPC method." + }, + "v1beta1QueryEvidenceResponse": { + "type": "object", + "properties": { + "evidence": { + "$ref": "#/definitions/protobufAny", + "description": "evidence returns the requested evidence." + } + }, + "description": "QueryEvidenceResponse is the response type for the Query/Evidence RPC method." + } + } +} diff --git a/x/gov/v1beta1/query.swagger.json b/x/gov/v1beta1/query.swagger.json new file mode 100644 index 000000000000..a0f66e154ff4 --- /dev/null +++ b/x/gov/v1beta1/query.swagger.json @@ -0,0 +1,785 @@ +{ + "swagger": "2.0", + "info": { + "title": "cosmos/gov/v1beta1/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/cosmos/gov/v1beta1/params/{params_type}": { + "get": { + "summary": "Params queries all parameters of the gov module.", + "operationId": "Query_Params", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryParamsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "params_type", + "description": "params_type defines which parameters to query for, can be one of \"voting\", \"tallying\" or \"deposit\".", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/gov/v1beta1/proposals": { + "get": { + "summary": "Proposals queries all proposals based on given status.", + "operationId": "Query_Proposals", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryProposalsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "proposal_status", + "description": "proposal_status defines the status of the proposals.\n\n - PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed.", + "in": "query", + "required": false, + "type": "string", + "enum": [ + "PROPOSAL_STATUS_UNSPECIFIED", + "PROPOSAL_STATUS_DEPOSIT_PERIOD", + "PROPOSAL_STATUS_VOTING_PERIOD", + "PROPOSAL_STATUS_PASSED", + "PROPOSAL_STATUS_REJECTED", + "PROPOSAL_STATUS_FAILED" + ], + "default": "PROPOSAL_STATUS_UNSPECIFIED" + }, + { + "name": "voter", + "description": "voter defines the voter address for the proposals.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "depositor", + "description": "depositor defines the deposit addresses from the proposals.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/gov/v1beta1/proposals/{proposal_id}": { + "get": { + "summary": "Proposal queries proposal details based on ProposalID.", + "operationId": "Query_Proposal", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryProposalResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "proposal_id", + "description": "proposal_id defines the unique id of the proposal.", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/gov/v1beta1/proposals/{proposal_id}/deposits": { + "get": { + "summary": "Deposits queries all deposits of a single proposal.", + "operationId": "Query_Deposits", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryDepositsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "proposal_id", + "description": "proposal_id defines the unique id of the proposal.", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/gov/v1beta1/proposals/{proposal_id}/deposits/{depositor}": { + "get": { + "summary": "Deposit queries single deposit information based proposalID, depositAddr.", + "operationId": "Query_Deposit", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryDepositResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "proposal_id", + "description": "proposal_id defines the unique id of the proposal.", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + }, + { + "name": "depositor", + "description": "depositor defines the deposit addresses from the proposals.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/gov/v1beta1/proposals/{proposal_id}/tally": { + "get": { + "summary": "TallyResult queries the tally of a proposal vote.", + "operationId": "Query_TallyResult", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryTallyResultResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "proposal_id", + "description": "proposal_id defines the unique id of the proposal.", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/gov/v1beta1/proposals/{proposal_id}/votes": { + "get": { + "summary": "Votes queries votes of a given proposal.", + "operationId": "Query_Votes", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryVotesResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "proposal_id", + "description": "proposal_id defines the unique id of the proposal.", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/gov/v1beta1/proposals/{proposal_id}/votes/{voter}": { + "get": { + "summary": "Vote queries voted information based on proposalID, voterAddr.", + "operationId": "Query_Vote", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryVoteResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "proposal_id", + "description": "proposal_id defines the unique id of the proposal.", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + }, + { + "name": "voter", + "description": "voter defines the oter address for the proposals.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "protobufAny": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := \u0026pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "runtimeError": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/protobufAny" + } + } + } + }, + "v1beta1Coin": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + }, + "v1beta1Deposit": { + "type": "object", + "properties": { + "proposal_id": { + "type": "string", + "format": "uint64" + }, + "depositor": { + "type": "string", + "format": "byte" + }, + "amount": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1Coin" + } + } + }, + "title": "Deposit defines an amount deposited by an account address to an active proposal" + }, + "v1beta1DepositParams": { + "type": "object", + "properties": { + "min_deposit": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1Coin" + }, + "description": "Minimum deposit for a proposal to enter voting period." + }, + "max_deposit_period": { + "type": "string", + "description": "Maximum period for Atom holders to deposit on a proposal. Initial value: 2 months." + } + }, + "title": "DepositParams defines the params around deposits for governance" + }, + "v1beta1PageRequest": { + "type": "object", + "properties": { + "key": { + "type": "string", + "format": "byte", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." + }, + "offset": { + "type": "string", + "format": "uint64", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." + }, + "limit": { + "type": "string", + "format": "uint64", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." + }, + "count_total": { + "type": "boolean", + "format": "boolean", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." + } + }, + "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", + "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" + }, + "v1beta1PageResponse": { + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + }, + "v1beta1Proposal": { + "type": "object", + "properties": { + "proposal_id": { + "type": "string", + "format": "uint64" + }, + "content": { + "$ref": "#/definitions/protobufAny" + }, + "status": { + "$ref": "#/definitions/v1beta1ProposalStatus" + }, + "final_tally_result": { + "$ref": "#/definitions/v1beta1TallyResult" + }, + "submit_time": { + "type": "string", + "format": "date-time" + }, + "deposit_end_time": { + "type": "string", + "format": "date-time" + }, + "total_deposit": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1Coin" + } + }, + "voting_start_time": { + "type": "string", + "format": "date-time" + }, + "voting_end_time": { + "type": "string", + "format": "date-time" + } + }, + "title": "Proposal defines the core field members of a governance proposal" + }, + "v1beta1ProposalStatus": { + "type": "string", + "enum": [ + "PROPOSAL_STATUS_UNSPECIFIED", + "PROPOSAL_STATUS_DEPOSIT_PERIOD", + "PROPOSAL_STATUS_VOTING_PERIOD", + "PROPOSAL_STATUS_PASSED", + "PROPOSAL_STATUS_REJECTED", + "PROPOSAL_STATUS_FAILED" + ], + "default": "PROPOSAL_STATUS_UNSPECIFIED", + "description": "- PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed.", + "title": "ProposalStatus is a type alias that represents a proposal status as a byte" + }, + "v1beta1QueryDepositResponse": { + "type": "object", + "properties": { + "deposit": { + "$ref": "#/definitions/v1beta1Deposit", + "description": "deposit defines the requested deposit." + } + }, + "description": "QueryDepositResponse is the response type for the Query/Deposit RPC method." + }, + "v1beta1QueryDepositsResponse": { + "type": "object", + "properties": { + "deposits": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1Deposit" + } + }, + "pagination": { + "$ref": "#/definitions/v1beta1PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryDepositsResponse is the response type for the Query/Deposits RPC method." + }, + "v1beta1QueryParamsResponse": { + "type": "object", + "properties": { + "voting_params": { + "$ref": "#/definitions/v1beta1VotingParams", + "description": "voting_params defines the parameters related to voting." + }, + "deposit_params": { + "$ref": "#/definitions/v1beta1DepositParams", + "description": "deposit_params defines the parameters related to deposit." + }, + "tally_params": { + "$ref": "#/definitions/v1beta1TallyParams", + "description": "tally_params defines the parameters related to tally." + } + }, + "description": "QueryParamsResponse is the response type for the Query/Params RPC method." + }, + "v1beta1QueryProposalResponse": { + "type": "object", + "properties": { + "proposal": { + "$ref": "#/definitions/v1beta1Proposal" + } + }, + "description": "QueryProposalResponse is the response type for the Query/Proposal RPC method." + }, + "v1beta1QueryProposalsResponse": { + "type": "object", + "properties": { + "proposals": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1Proposal" + } + }, + "pagination": { + "$ref": "#/definitions/v1beta1PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryProposalsResponse is the response type for the Query/Proposals RPC method." + }, + "v1beta1QueryTallyResultResponse": { + "type": "object", + "properties": { + "tally": { + "$ref": "#/definitions/v1beta1TallyResult", + "description": "tally defines the requested tally." + } + }, + "description": "QueryTallyResultResponse is the response type for the Query/Tally RPC method." + }, + "v1beta1QueryVoteResponse": { + "type": "object", + "properties": { + "vote": { + "$ref": "#/definitions/v1beta1Vote", + "description": "vote defined the queried vote." + } + }, + "description": "QueryVoteResponse is the response type for the Query/Vote RPC method." + }, + "v1beta1QueryVotesResponse": { + "type": "object", + "properties": { + "votes": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1Vote" + }, + "description": "votes defined the queried votes." + }, + "pagination": { + "$ref": "#/definitions/v1beta1PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryVotesResponse is the response type for the Query/Votes RPC method." + }, + "v1beta1TallyParams": { + "type": "object", + "properties": { + "quorum": { + "type": "string", + "format": "byte", + "description": "Minimum percentage of total stake needed to vote for a result to be considered valid." + }, + "threshold": { + "type": "string", + "format": "byte", + "description": "Minimum proportion of Yes votes for proposal to pass. Initial value: 0.5." + }, + "veto": { + "type": "string", + "format": "byte", + "description": "Minimum value of Veto votes to Total votes ratio for proposal to be vetoed. Initial value: 1/3." + } + }, + "title": "TallyParams defines the params around Tallying votes in governance" + }, + "v1beta1TallyResult": { + "type": "object", + "properties": { + "yes": { + "type": "string" + }, + "abstain": { + "type": "string" + }, + "no": { + "type": "string" + }, + "no_with_veto": { + "type": "string" + } + }, + "title": "TallyResult defines a standard tally for a proposal" + }, + "v1beta1Vote": { + "type": "object", + "properties": { + "proposal_id": { + "type": "string", + "format": "uint64" + }, + "voter": { + "type": "string", + "format": "byte" + }, + "option": { + "$ref": "#/definitions/v1beta1VoteOption" + } + }, + "description": "Vote defines a vote on a governance proposal. A vote corresponds to a proposal\nID, the voter, and the vote option." + }, + "v1beta1VoteOption": { + "type": "string", + "enum": [ + "VOTE_OPTION_UNSPECIFIED", + "VOTE_OPTION_YES", + "VOTE_OPTION_ABSTAIN", + "VOTE_OPTION_NO", + "VOTE_OPTION_NO_WITH_VETO" + ], + "default": "VOTE_OPTION_UNSPECIFIED", + "description": "- VOTE_OPTION_UNSPECIFIED: VOTE_OPTION_UNSPECIFIED defines a no-op vote option.\n - VOTE_OPTION_YES: VOTE_OPTION_YES defines a yes vote option.\n - VOTE_OPTION_ABSTAIN: VOTE_OPTION_ABSTAIN defines an abstain vote option.\n - VOTE_OPTION_NO: VOTE_OPTION_NO defines a no vote option.\n - VOTE_OPTION_NO_WITH_VETO: VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option.", + "title": "VoteOption defines a vote option" + }, + "v1beta1VotingParams": { + "type": "object", + "properties": { + "voting_period": { + "type": "string", + "description": "Length of the voting period." + } + }, + "title": "VotingParams defines the params around Voting in governance" + } + } +} diff --git a/x/ibc/channel/query.swagger.json b/x/ibc/channel/query.swagger.json new file mode 100644 index 000000000000..e4e5ffc103fe --- /dev/null +++ b/x/ibc/channel/query.swagger.json @@ -0,0 +1,982 @@ +{ + "swagger": "2.0", + "info": { + "title": "ibc/channel/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/ibc/channel/v1beta1/channels": { + "get": { + "summary": "Channels queries all the IBC channels of a chain.", + "operationId": "Query_Channels", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/channelQueryChannelsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}": { + "get": { + "summary": "Channel queries an IBC Channel.", + "operationId": "Query_Channel", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/channelQueryChannelResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/client_state": { + "get": { + "summary": "ChannelClientState queries for the client state for the channel associated\nwith the provided channel identifiers.", + "operationId": "Query_ChannelClientState", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/channelQueryChannelClientStateResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/consensus_state/{height}": { + "get": { + "summary": "ChannelConsensusState queries for the consensus state for the channel\nassociated with the provided channel identifiers.", + "operationId": "Query_ChannelConsensusState", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/channelQueryChannelConsensusStateResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "height", + "description": "height of the consensus state", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/next_sequence": { + "get": { + "summary": "NextSequenceReceive returns the next receive sequence for a given channel.", + "operationId": "Query_NextSequenceReceive", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/channelQueryNextSequenceReceiveResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_acks/{sequence}": { + "get": { + "summary": "PacketAcknowledgement queries a stored packet acknowledgement hash.", + "operationId": "Query_PacketAcknowledgement", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/channelQueryPacketAcknowledgementResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "sequence", + "description": "packet sequence", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments": { + "get": { + "summary": "PacketCommitments returns the all the packet commitments hashes associated\nwith a channel.", + "operationId": "Query_PacketCommitments", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/channelQueryPacketCommitmentsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_commitment_sequences}/packet_acks/{acknowledgements}/unrelayed_packets": { + "get": { + "summary": "UnrelayedPackets returns all the unrelayed IBC packets associated with a\nchannel and sequences.", + "operationId": "Query_UnrelayedPackets", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/channelQueryUnrelayedPacketsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "packet_commitment_sequences", + "description": "list of packet sequences", + "in": "path", + "required": true, + "type": "array", + "items": { + "type": "string", + "format": "uint64" + }, + "collectionFormat": "csv", + "minItems": 1 + }, + { + "name": "acknowledgements", + "description": "flag indicating if the return value is packet commitments or\nacknowledgements", + "in": "path", + "required": true, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/{sequence}": { + "get": { + "summary": "PacketCommitment queries a stored packet commitment hash.", + "operationId": "Query_PacketCommitment", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/channelQueryPacketCommitmentResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "sequence", + "description": "packet sequence", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/connections/{connection}/channels": { + "get": { + "summary": "ConnectionChannels queries all the channels associated with a connection\nend.", + "operationId": "Query_ConnectionChannels", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/channelQueryConnectionChannelsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "connection", + "description": "connection unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "channelChannel": { + "type": "object", + "properties": { + "state": { + "$ref": "#/definitions/channelState", + "title": "current state of the channel end" + }, + "ordering": { + "$ref": "#/definitions/channelOrder", + "title": "whether the channel is ordered or unordered" + }, + "counterparty": { + "$ref": "#/definitions/channelCounterparty", + "title": "counterparty channel end" + }, + "connection_hops": { + "type": "array", + "items": { + "type": "string" + }, + "title": "list of connection identifiers, in order, along which packets sent on this\nchannel will travel" + }, + "version": { + "type": "string", + "title": "opaque channel version, which is agreed upon during the handshake" + } + }, + "description": "Channel defines pipeline for exactly-once packet delivery between specific\nmodules on separate blockchains, which has at least one end capable of sending\npackets and one end capable of receiving packets." + }, + "channelCounterparty": { + "type": "object", + "properties": { + "port_id": { + "type": "string", + "description": "port on the counterparty chain which owns the other end of the channel." + }, + "channel_id": { + "type": "string", + "title": "channel end on the counterparty chain" + } + }, + "title": "Counterparty defines a channel end counterparty" + }, + "channelIdentifiedChannel": { + "type": "object", + "properties": { + "state": { + "$ref": "#/definitions/channelState", + "title": "current state of the channel end" + }, + "ordering": { + "$ref": "#/definitions/channelOrder", + "title": "whether the channel is ordered or unordered" + }, + "counterparty": { + "$ref": "#/definitions/channelCounterparty", + "title": "counterparty channel end" + }, + "connection_hops": { + "type": "array", + "items": { + "type": "string" + }, + "title": "list of connection identifiers, in order, along which packets sent on this\nchannel will travel" + }, + "version": { + "type": "string", + "title": "opaque channel version, which is agreed upon during the handshake" + }, + "port_id": { + "type": "string", + "title": "port identifier" + }, + "channel_id": { + "type": "string", + "title": "channel identifier" + } + }, + "description": "IdentifiedChannel defines a channel with additional port and channel identifier\nfields." + }, + "channelOrder": { + "type": "string", + "enum": [ + "ORDER_NONE_UNSPECIFIED", + "ORDER_UNORDERED", + "ORDER_ORDERED" + ], + "default": "ORDER_NONE_UNSPECIFIED", + "description": "- ORDER_NONE_UNSPECIFIED: zero-value for channel ordering\n - ORDER_UNORDERED: packets can be delivered in any order, which may differ from the order in which they were sent.\n - ORDER_ORDERED: packets are delivered exactly in the order which they were sent", + "title": "Order defines if a channel is ORDERED or UNORDERED" + }, + "channelPacketAckCommitment": { + "type": "object", + "properties": { + "port_id": { + "type": "string", + "description": "channel port identifier." + }, + "channel_id": { + "type": "string", + "description": "channel unique identifier." + }, + "sequence": { + "type": "string", + "format": "uint64", + "description": "packet sequence." + }, + "hash": { + "type": "string", + "format": "byte", + "description": "packet commitment hash." + } + }, + "description": "PacketAckCommitment defines the genesis type necessary to retrieve and store\nacknowlegements." + }, + "channelQueryChannelClientStateResponse": { + "type": "object", + "properties": { + "identified_client_state": { + "$ref": "#/definitions/clientIdentifiedClientState", + "title": "client state associated with the channel" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryChannelClientStateResponse is the Response type for the\nQuery/QueryChannelClientState RPC method" + }, + "channelQueryChannelConsensusStateResponse": { + "type": "object", + "properties": { + "consensus_state": { + "$ref": "#/definitions/protobufAny", + "title": "consensus state associated with the channel" + }, + "client_id": { + "type": "string", + "title": "client ID associated with the consensus state" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryChannelClientStateResponse is the Response type for the\nQuery/QueryChannelClientState RPC method" + }, + "channelQueryChannelResponse": { + "type": "object", + "properties": { + "channel": { + "$ref": "#/definitions/channelChannel", + "title": "channel associated with the request identifiers" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "description": "QueryChannelResponse is the response type for the Query/Channel RPC method.\nBesides the Channel end, it includes a proof and the height from which the\nproof was retrieved." + }, + "channelQueryChannelsResponse": { + "type": "object", + "properties": { + "channels": { + "type": "array", + "items": { + "$ref": "#/definitions/channelIdentifiedChannel" + }, + "description": "list of stored channels of the chain." + }, + "pagination": { + "$ref": "#/definitions/v1beta1PageResponse", + "title": "pagination response" + }, + "height": { + "type": "string", + "format": "int64", + "title": "query block height" + } + }, + "description": "QueryChannelsResponse is the response type for the Query/Channels RPC method." + }, + "channelQueryConnectionChannelsResponse": { + "type": "object", + "properties": { + "channels": { + "type": "array", + "items": { + "$ref": "#/definitions/channelIdentifiedChannel" + }, + "description": "list of channels associated with a connection." + }, + "pagination": { + "$ref": "#/definitions/v1beta1PageResponse", + "title": "pagination response" + }, + "height": { + "type": "string", + "format": "int64", + "title": "query block height" + } + }, + "title": "QueryConnectionChannelsResponse is the Response type for the\nQuery/QueryConnectionChannels RPC method" + }, + "channelQueryNextSequenceReceiveResponse": { + "type": "object", + "properties": { + "next_sequence_receive": { + "type": "string", + "format": "uint64", + "title": "next sequence receive number" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QuerySequenceResponse is the request type for the\nQuery/QueryNextSequenceReceiveResponse RPC method" + }, + "channelQueryPacketAcknowledgementResponse": { + "type": "object", + "properties": { + "acknowledgement": { + "type": "string", + "format": "byte", + "title": "packet associated with the request fields" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryPacketAcknowledgementResponse defines the client query response for a\npacket which also includes a proof, its path and the height form which the\nproof was retrieved" + }, + "channelQueryPacketCommitmentResponse": { + "type": "object", + "properties": { + "commitment": { + "type": "string", + "format": "byte", + "title": "packet associated with the request fields" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryPacketCommitmentResponse defines the client query response for a packet\nwhich also includes a proof, its path and the height form which the proof was\nretrieved" + }, + "channelQueryPacketCommitmentsResponse": { + "type": "object", + "properties": { + "commitments": { + "type": "array", + "items": { + "$ref": "#/definitions/channelPacketAckCommitment" + } + }, + "pagination": { + "$ref": "#/definitions/v1beta1PageResponse", + "title": "pagination response" + }, + "height": { + "type": "string", + "format": "int64", + "title": "query block height" + } + }, + "title": "QueryPacketCommitmentsResponse is the request type for the\nQuery/QueryPacketCommitments RPC method" + }, + "channelQueryUnrelayedPacketsResponse": { + "type": "object", + "properties": { + "sequences": { + "type": "array", + "items": { + "type": "string", + "format": "uint64" + }, + "title": "list of unrelayed packet sequences" + }, + "height": { + "type": "string", + "format": "int64", + "title": "query block height" + } + }, + "title": "QueryUnrelayedPacketsResponse is the request type for the\nQuery/UnrelayedPacketCommitments RPC method" + }, + "channelState": { + "type": "string", + "enum": [ + "STATE_UNINITIALIZED_UNSPECIFIED", + "STATE_INIT", + "STATE_TRYOPEN", + "STATE_OPEN", + "STATE_CLOSED" + ], + "default": "STATE_UNINITIALIZED_UNSPECIFIED", + "description": "State defines if a channel is in one of the following states:\nCLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.\n\n - STATE_UNINITIALIZED_UNSPECIFIED: Default State\n - STATE_INIT: A channel has just started the opening handshake.\n - STATE_TRYOPEN: A channel has acknowledged the handshake step on the counterparty chain.\n - STATE_OPEN: A channel has completed the handshake. Open channels are\nready to send and receive packets.\n - STATE_CLOSED: A channel has been closed and can no longer be used to send or receive packets." + }, + "clientIdentifiedClientState": { + "type": "object", + "properties": { + "id": { + "type": "string", + "title": "client identifier" + }, + "client_state": { + "$ref": "#/definitions/protobufAny" + } + }, + "description": "IdentifiedClientState defines a client state with additional client identifier field." + }, + "protobufAny": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := \u0026pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "runtimeError": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/protobufAny" + } + } + } + }, + "v1beta1PageRequest": { + "type": "object", + "properties": { + "key": { + "type": "string", + "format": "byte", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." + }, + "offset": { + "type": "string", + "format": "uint64", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." + }, + "limit": { + "type": "string", + "format": "uint64", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." + }, + "count_total": { + "type": "boolean", + "format": "boolean", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." + } + }, + "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", + "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" + }, + "v1beta1PageResponse": { + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + } +} diff --git a/x/ibc/connection/query.swagger.json b/x/ibc/connection/query.swagger.json new file mode 100644 index 000000000000..570052738057 --- /dev/null +++ b/x/ibc/connection/query.swagger.json @@ -0,0 +1,520 @@ +{ + "swagger": "2.0", + "info": { + "title": "ibc/connection/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/ibc/connection/v1beta1/client_connections/{client_id}": { + "get": { + "summary": "ClientConnections queries the connection paths associated with a client\nstate.", + "operationId": "Query_ClientConnections", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/connectionQueryClientConnectionsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "client_id", + "description": "client identifier associated with a connection", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/connection/v1beta1/connections": { + "get": { + "summary": "Connections queries all the IBC connections of a chain.", + "operationId": "Query_Connections", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/connectionQueryConnectionsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/connection/v1beta1/connections/{connection_id}": { + "get": { + "summary": "Connection queries an IBC connection end.", + "operationId": "Query_Connection", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/connectionQueryConnectionResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "connection_id", + "description": "connection unique identifier", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/connection/v1beta1/connections/{connection_id}/client_state": { + "get": { + "summary": "ConnectionClientState queries the client state associated with the\nconnection.", + "operationId": "Query_ConnectionClientState", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/connectionQueryConnectionClientStateResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "connection_id", + "description": "connection identifier", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/connection/v1beta1/connections/{connection_id}/consensus_state": { + "get": { + "summary": "ConnectionConsensusState queries the consensus state associated with the\nconnection.", + "operationId": "Query_ConnectionConsensusState", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/connectionQueryConnectionConsensusStateResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "connection_id", + "description": "connection identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "height", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + } + ], + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "clientIdentifiedClientState": { + "type": "object", + "properties": { + "id": { + "type": "string", + "title": "client identifier" + }, + "client_state": { + "$ref": "#/definitions/protobufAny" + } + }, + "description": "IdentifiedClientState defines a client state with additional client identifier field." + }, + "commitmentMerklePrefix": { + "type": "object", + "properties": { + "key_prefix": { + "type": "string", + "format": "byte" + } + }, + "title": "MerklePrefix is merkle path prefixed to the key.\nThe constructed key from the Path and the key will be append(Path.KeyPath, append(Path.KeyPrefix, key...))" + }, + "connectionConnectionEnd": { + "type": "object", + "properties": { + "client_id": { + "type": "string", + "description": "client associated with this connection." + }, + "versions": { + "type": "array", + "items": { + "type": "string" + }, + "title": "IBC version which can be utilised to determine encodings or protocols for\nchannels or packets utilising this connection" + }, + "state": { + "$ref": "#/definitions/connectionState", + "description": "current state of the connection end." + }, + "counterparty": { + "$ref": "#/definitions/connectionCounterparty", + "description": "counterparty chain associated with this connection." + } + }, + "description": "ConnectionEnd defines a stateful object on a chain connected to another\nseparate one. NOTE: there must only be 2 defined ConnectionEnds to establish\na connection between two chains." + }, + "connectionCounterparty": { + "type": "object", + "properties": { + "client_id": { + "type": "string", + "description": "identifies the client on the counterparty chain associated with a given\nconnection." + }, + "connection_id": { + "type": "string", + "description": "identifies the connection end on the counterparty chain associated with a\ngiven connection." + }, + "prefix": { + "$ref": "#/definitions/commitmentMerklePrefix", + "title": "commitment merkle prefix of the counterparty chain" + } + }, + "description": "Counterparty defines the counterparty chain associated with a connection end." + }, + "connectionIdentifiedConnection": { + "type": "object", + "properties": { + "id": { + "type": "string", + "description": "connection identifier." + }, + "client_id": { + "type": "string", + "description": "client associated with this connection." + }, + "versions": { + "type": "array", + "items": { + "type": "string" + }, + "title": "IBC version which can be utilised to determine encodings or protocols for\nchannels or packets utilising this connection" + }, + "state": { + "$ref": "#/definitions/connectionState", + "description": "current state of the connection end." + }, + "counterparty": { + "$ref": "#/definitions/connectionCounterparty", + "description": "counterparty chain associated with this connection." + } + }, + "description": "IdentifiedConnection defines a connection with additional connection\nidentifier field." + }, + "connectionQueryClientConnectionsResponse": { + "type": "object", + "properties": { + "connection_paths": { + "type": "array", + "items": { + "type": "string" + }, + "description": "slice of all the connection paths associated with a client." + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was generated" + } + }, + "title": "QueryClientConnectionsResponse is the response type for the\nQuery/ClientConnections RPC method" + }, + "connectionQueryConnectionClientStateResponse": { + "type": "object", + "properties": { + "identified_client_state": { + "$ref": "#/definitions/clientIdentifiedClientState", + "title": "client state associated with the channel" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryConnectionClientStateResponse is the response type for the\nQuery/ConnectionClientState RPC method" + }, + "connectionQueryConnectionConsensusStateResponse": { + "type": "object", + "properties": { + "consensus_state": { + "$ref": "#/definitions/protobufAny", + "title": "consensus state associated with the channel" + }, + "client_id": { + "type": "string", + "title": "client ID associated with the consensus state" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryConnectionConsensusStateResponse is the response type for the\nQuery/ConnectionConsensusState RPC method" + }, + "connectionQueryConnectionResponse": { + "type": "object", + "properties": { + "connection": { + "$ref": "#/definitions/connectionConnectionEnd", + "title": "connection associated with the request identifier" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "description": "QueryConnectionResponse is the response type for the Query/Connection RPC\nmethod. Besides the connection end, it includes a proof and the height from\nwhich the proof was retrieved." + }, + "connectionQueryConnectionsResponse": { + "type": "object", + "properties": { + "connections": { + "type": "array", + "items": { + "$ref": "#/definitions/connectionIdentifiedConnection" + }, + "description": "list of stored connections of the chain." + }, + "pagination": { + "$ref": "#/definitions/v1beta1PageResponse", + "title": "pagination response" + }, + "height": { + "type": "string", + "format": "int64", + "title": "query block height" + } + }, + "description": "QueryConnectionsResponse is the response type for the Query/Connections RPC\nmethod." + }, + "connectionState": { + "type": "string", + "enum": [ + "STATE_UNINITIALIZED_UNSPECIFIED", + "STATE_INIT", + "STATE_TRYOPEN", + "STATE_OPEN" + ], + "default": "STATE_UNINITIALIZED_UNSPECIFIED", + "description": "State defines if a connection is in one of the following states:\nINIT, TRYOPEN, OPEN or UNINITIALIZED.\n\n - STATE_UNINITIALIZED_UNSPECIFIED: Default State\n - STATE_INIT: A connection end has just started the opening handshake.\n - STATE_TRYOPEN: A connection end has acknowledged the handshake step on the counterparty\nchain.\n - STATE_OPEN: A connection end has completed the handshake." + }, + "protobufAny": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := \u0026pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "runtimeError": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/protobufAny" + } + } + } + }, + "v1beta1PageRequest": { + "type": "object", + "properties": { + "key": { + "type": "string", + "format": "byte", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." + }, + "offset": { + "type": "string", + "format": "uint64", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." + }, + "limit": { + "type": "string", + "format": "uint64", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." + }, + "count_total": { + "type": "boolean", + "format": "boolean", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." + } + }, + "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", + "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" + }, + "v1beta1PageResponse": { + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + } +} diff --git a/x/ibc/transfer/query.swagger.json b/x/ibc/transfer/query.swagger.json new file mode 100644 index 000000000000..11ec227783a0 --- /dev/null +++ b/x/ibc/transfer/query.swagger.json @@ -0,0 +1,273 @@ +{ + "swagger": "2.0", + "info": { + "title": "ibc/transfer/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/ibc_transfer/v1beta1/denom_traces": { + "get": { + "summary": "DenomTraces queries all denomination traces.", + "operationId": "Query_DenomTraces", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/transferQueryDenomTracesResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc_transfer/v1beta1/denom_traces/{hash}": { + "get": { + "summary": "DenomTrace queries a denomination trace information.", + "operationId": "Query_DenomTrace", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/transferQueryDenomTraceResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "hash", + "description": "hash (in hex format) of the denomination trace information.", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc_transfer/v1beta1/params": { + "get": { + "summary": "Params queries all parameters of the ibc-transfer module.", + "operationId": "Query_Params", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/transferQueryParamsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "protobufAny": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + }, + "runtimeError": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/protobufAny" + } + } + } + }, + "transferDenomTrace": { + "type": "object", + "properties": { + "path": { + "type": "string", + "description": "path defines the chain of port/channel identifiers used for tracing the source of the fungible\ntoken." + }, + "base_denom": { + "type": "string", + "description": "base denomination of the relayed fungible token." + } + }, + "description": "DenomTrace contains the base denomination for ICS20 fungible tokens and the source tracing\ninformation path." + }, + "transferParams": { + "type": "object", + "properties": { + "send_enabled": { + "type": "boolean", + "format": "boolean", + "description": "send_enabled enables or disables all cross-chain token transfers from this chain." + }, + "receive_enabled": { + "type": "boolean", + "format": "boolean", + "description": "receive_enabled enables or disables all cross-chain token transfers to this chain." + } + }, + "description": "Params defines the set of IBC transfer parameters.\nNOTE: To prevent a single token from being transferred, set the TransfersEnabled parameter to\ntrue and then set the bank module's SendEnabled parameter for the denomination to false." + }, + "transferQueryDenomTraceResponse": { + "type": "object", + "properties": { + "denom_trace": { + "$ref": "#/definitions/transferDenomTrace", + "description": "denom_trace returns the requested denomination trace information." + } + }, + "description": "QueryDenomTraceResponse is the response type for the Query/DenomTrace RPC method." + }, + "transferQueryDenomTracesResponse": { + "type": "object", + "properties": { + "denom_traces": { + "type": "array", + "items": { + "$ref": "#/definitions/transferDenomTrace" + }, + "description": "denom_traces returns all denominations trace information." + }, + "pagination": { + "$ref": "#/definitions/v1beta1PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryConnectionsResponse is the response type for the Query/DenomTraces RPC method." + }, + "transferQueryParamsResponse": { + "type": "object", + "properties": { + "params": { + "$ref": "#/definitions/transferParams", + "description": "params defines the parameters of the module." + } + }, + "description": "QueryParamsResponse is the response type for the Query/Params RPC method." + }, + "v1beta1PageRequest": { + "type": "object", + "properties": { + "key": { + "type": "string", + "format": "byte", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." + }, + "offset": { + "type": "string", + "format": "uint64", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." + }, + "limit": { + "type": "string", + "format": "uint64", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." + }, + "count_total": { + "type": "boolean", + "format": "boolean", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." + } + }, + "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", + "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" + }, + "v1beta1PageResponse": { + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + } +} diff --git a/x/mint/v1beta1/query.swagger.json b/x/mint/v1beta1/query.swagger.json new file mode 100644 index 000000000000..b9bc1d0e1767 --- /dev/null +++ b/x/mint/v1beta1/query.swagger.json @@ -0,0 +1,182 @@ +{ + "swagger": "2.0", + "info": { + "title": "cosmos/mint/v1beta1/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/cosmos/mint/v1beta1/annual_provisions": { + "get": { + "summary": "AnnualProvisions current minting annual provisions value.", + "operationId": "Query_AnnualProvisions", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryAnnualProvisionsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/mint/v1beta1/inflation": { + "get": { + "summary": "Inflation returns the current minting inflation value.", + "operationId": "Query_Inflation", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryInflationResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/mint/v1beta1/params": { + "get": { + "summary": "Params returns the total set of minting parameters.", + "operationId": "Query_Params", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryParamsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "protobufAny": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + }, + "runtimeError": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/protobufAny" + } + } + } + }, + "v1beta1Params": { + "type": "object", + "properties": { + "mint_denom": { + "type": "string", + "title": "type of coin to mint" + }, + "inflation_rate_change": { + "type": "string", + "title": "maximum annual change in inflation rate" + }, + "inflation_max": { + "type": "string", + "title": "maximum inflation rate" + }, + "inflation_min": { + "type": "string", + "title": "minimum inflation rate" + }, + "goal_bonded": { + "type": "string", + "title": "goal of percent bonded atoms" + }, + "blocks_per_year": { + "type": "string", + "format": "uint64", + "title": "expected blocks per year" + } + }, + "title": "mint parameters" + }, + "v1beta1QueryAnnualProvisionsResponse": { + "type": "object", + "properties": { + "annual_provisions": { + "type": "string", + "format": "byte", + "description": "annual_provisions is the current minting annual provisions value." + } + }, + "description": "QueryAnnualProvisionsResponse is the response type for the Query/AnnualProvisions RPC method." + }, + "v1beta1QueryInflationResponse": { + "type": "object", + "properties": { + "inflation": { + "type": "string", + "format": "byte", + "description": "inflation is the current minting inflation value." + } + }, + "description": "QueryInflationResponse is the response type for the Query/Inflation RPC method." + }, + "v1beta1QueryParamsResponse": { + "type": "object", + "properties": { + "params": { + "$ref": "#/definitions/v1beta1Params", + "description": "params defines the parameters of the module." + } + }, + "description": "QueryParamsResponse is the response type for the Query/Params RPC method." + } + } +} diff --git a/x/params/v1beta1/query.swagger.json b/x/params/v1beta1/query.swagger.json new file mode 100644 index 000000000000..f24fcd582ba0 --- /dev/null +++ b/x/params/v1beta1/query.swagger.json @@ -0,0 +1,114 @@ +{ + "swagger": "2.0", + "info": { + "title": "cosmos/params/v1beta1/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/cosmos/params/v1beta1/params": { + "get": { + "summary": "Params queries a specific parameter of a module, given its subspace and key.", + "operationId": "Query_Params", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryParamsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "subspace", + "description": "subspace defines the module to query the parameter for.", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "key", + "description": "key defines the key of the parameter in the subspace.", + "in": "query", + "required": false, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "protobufAny": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + }, + "runtimeError": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/protobufAny" + } + } + } + }, + "v1beta1ParamChange": { + "type": "object", + "properties": { + "subspace": { + "type": "string" + }, + "key": { + "type": "string" + }, + "value": { + "type": "string" + } + }, + "description": "ParamChange defines a parameter change." + }, + "v1beta1QueryParamsResponse": { + "type": "object", + "properties": { + "param": { + "$ref": "#/definitions/v1beta1ParamChange", + "description": "param defines the queried parameter." + } + }, + "description": "QueryParamsResponse is response type for the Query/Params RPC method." + } + } +} diff --git a/x/slashing/v1beta1/query.swagger.json b/x/slashing/v1beta1/query.swagger.json new file mode 100644 index 000000000000..6144e41a78a8 --- /dev/null +++ b/x/slashing/v1beta1/query.swagger.json @@ -0,0 +1,302 @@ +{ + "swagger": "2.0", + "info": { + "title": "cosmos/slashing/v1beta1/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/cosmos/slashing/v1beta1/params": { + "get": { + "summary": "Params queries the parameters of slashing module", + "operationId": "Query_Params", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryParamsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/slashing/v1beta1/signing_infos": { + "get": { + "summary": "SigningInfos queries signing info of all validators", + "operationId": "Query_SigningInfos", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QuerySigningInfosResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/slashing/v1beta1/signing_infos/{cons_address}": { + "get": { + "summary": "SigningInfo queries the signing info of given cons address", + "operationId": "Query_SigningInfo", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QuerySigningInfoResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "cons_address", + "description": "cons_address is the address to query signing info of", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "protobufAny": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + }, + "runtimeError": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/protobufAny" + } + } + } + }, + "v1beta1PageRequest": { + "type": "object", + "properties": { + "key": { + "type": "string", + "format": "byte", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." + }, + "offset": { + "type": "string", + "format": "uint64", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." + }, + "limit": { + "type": "string", + "format": "uint64", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." + }, + "count_total": { + "type": "boolean", + "format": "boolean", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." + } + }, + "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", + "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" + }, + "v1beta1PageResponse": { + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + }, + "v1beta1Params": { + "type": "object", + "properties": { + "signed_blocks_window": { + "type": "string", + "format": "int64" + }, + "min_signed_per_window": { + "type": "string", + "format": "byte" + }, + "downtime_jail_duration": { + "type": "string" + }, + "slash_fraction_double_sign": { + "type": "string", + "format": "byte" + }, + "slash_fraction_downtime": { + "type": "string", + "format": "byte" + } + }, + "title": "Params - used for initializing default parameter for slashing at genesis" + }, + "v1beta1QueryParamsResponse": { + "type": "object", + "properties": { + "params": { + "$ref": "#/definitions/v1beta1Params" + } + }, + "title": "QueryParamsResponse is the response type for the Query/Params RPC method" + }, + "v1beta1QuerySigningInfoResponse": { + "type": "object", + "properties": { + "val_signing_info": { + "$ref": "#/definitions/v1beta1ValidatorSigningInfo", + "title": "val_signing_info is the signing info of requested val cons address" + } + }, + "title": "QuerySigningInfoResponse is the response type for the Query/SigningInfo RPC method" + }, + "v1beta1QuerySigningInfosResponse": { + "type": "object", + "properties": { + "info": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1ValidatorSigningInfo" + }, + "title": "info is the signing info of all validators" + }, + "pagination": { + "$ref": "#/definitions/v1beta1PageResponse" + } + }, + "title": "QuerySigningInfosResponse is the response type for the Query/SigningInfos RPC method" + }, + "v1beta1ValidatorSigningInfo": { + "type": "object", + "properties": { + "address": { + "type": "string", + "format": "byte" + }, + "start_height": { + "type": "string", + "format": "int64", + "title": "height at which validator was first a candidate OR was unjailed" + }, + "index_offset": { + "type": "string", + "format": "int64", + "title": "index offset into signed block bit array" + }, + "jailed_until": { + "type": "string", + "format": "date-time", + "title": "timestamp validator cannot be unjailed until" + }, + "tombstoned": { + "type": "boolean", + "format": "boolean", + "title": "whether or not a validator has been tombstoned (killed out of validator set)" + }, + "missed_blocks_counter": { + "type": "string", + "format": "int64", + "title": "missed blocks counter (to avoid scanning the array every time)" + } + }, + "title": "ValidatorSigningInfo defines the signing info for a validator" + } + } +} diff --git a/x/staking/types/staking.pb.go b/x/staking/types/staking.pb.go index 456cc2457be9..bf8668615614 100644 --- a/x/staking/types/staking.pb.go +++ b/x/staking/types/staking.pb.go @@ -1263,569 +1263,571 @@ func (this *Pool) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_ func StakingDescription() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) { d := &github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet{} var gzipped = []byte{ - // 8985 bytes of a gzipped FileDescriptorSet - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6d, 0x74, 0x1c, 0xd7, - 0x75, 0x18, 0x67, 0x3f, 0x80, 0xdd, 0xbb, 0xf8, 0x58, 0x3c, 0x80, 0xd0, 0x72, 0x49, 0x02, 0xd4, - 0x48, 0x96, 0x28, 0x4a, 0x5a, 0x48, 0x14, 0x45, 0x51, 0x4b, 0xdb, 0x32, 0x16, 0x58, 0x82, 0x20, - 0xf1, 0xa5, 0x01, 0x40, 0xc9, 0x76, 0xd2, 0x3d, 0x83, 0xd9, 0x87, 0xc5, 0x88, 0xb3, 0x33, 0xa3, - 0x99, 0x59, 0x12, 0xa0, 0xed, 0x73, 0x94, 0xf8, 0xa3, 0xb1, 0xda, 0xd4, 0xce, 0xc7, 0x69, 0x65, - 0xc7, 0x72, 0x65, 0xbb, 0xad, 0x53, 0xa7, 0x6d, 0x92, 0x3a, 0x4d, 0x9b, 0xa6, 0xa7, 0x75, 0x5a, - 0x27, 0x71, 0xda, 0xa6, 0x47, 0x3a, 0x75, 0xdb, 0x34, 0xa7, 0xa5, 0x53, 0xd9, 0xa7, 0x75, 0x5c, - 0xb7, 0x49, 0x59, 0xf5, 0x53, 0x3f, 0x92, 0xf3, 0xbe, 0xe6, 0x63, 0x3f, 0xb0, 0xbb, 0x10, 0x25, - 0x5b, 0x27, 0xfa, 0x85, 0x7d, 0xf7, 0xdd, 0x7b, 0xdf, 0xbd, 0xf7, 0xdd, 0x7b, 0xdf, 0x7d, 0x6f, - 0xde, 0x0c, 0xe0, 0xe7, 0xce, 0xc3, 0x89, 0x9a, 0x65, 0xd5, 0x0c, 0x3c, 0x63, 0x3b, 0x96, 0x67, - 0x6d, 0x35, 0xb6, 0x67, 0xaa, 0xd8, 0xd5, 0x1c, 0xdd, 0xf6, 0x2c, 0xa7, 0x40, 0x61, 0x68, 0x94, - 0x61, 0x14, 0x04, 0x86, 0xbc, 0x0c, 0x63, 0x17, 0x74, 0x03, 0xcf, 0xfb, 0x88, 0xeb, 0xd8, 0x43, - 0xe7, 0x20, 0xb1, 0xad, 0x1b, 0x38, 0x27, 0x9d, 0x88, 0x9f, 0xcc, 0x9c, 0xbe, 0xbb, 0xd0, 0x44, - 0x54, 0x88, 0x52, 0xac, 0x11, 0xb0, 0x42, 0x29, 0xe4, 0xef, 0x24, 0x60, 0xbc, 0x4d, 0x2f, 0x42, - 0x90, 0x30, 0xd5, 0x3a, 0xe1, 0x28, 0x9d, 0x4c, 0x2b, 0xf4, 0x37, 0xca, 0xc1, 0xa0, 0xad, 0x6a, - 0x57, 0xd5, 0x1a, 0xce, 0xc5, 0x28, 0x58, 0x34, 0xd1, 0x14, 0x40, 0x15, 0xdb, 0xd8, 0xac, 0x62, - 0x53, 0xdb, 0xcb, 0xc5, 0x4f, 0xc4, 0x4f, 0xa6, 0x95, 0x10, 0x04, 0xdd, 0x0f, 0x63, 0x76, 0x63, - 0xcb, 0xd0, 0xb5, 0x4a, 0x08, 0x0d, 0x4e, 0xc4, 0x4f, 0x26, 0x95, 0x2c, 0xeb, 0x98, 0x0f, 0x90, - 0xef, 0x85, 0xd1, 0xeb, 0x58, 0xbd, 0x1a, 0x46, 0xcd, 0x50, 0xd4, 0x11, 0x02, 0x0e, 0x21, 0xce, - 0xc1, 0x50, 0x1d, 0xbb, 0xae, 0x5a, 0xc3, 0x15, 0x6f, 0xcf, 0xc6, 0xb9, 0x04, 0xd5, 0xfe, 0x44, - 0x8b, 0xf6, 0xcd, 0x9a, 0x67, 0x38, 0xd5, 0xc6, 0x9e, 0x8d, 0xd1, 0x2c, 0xa4, 0xb1, 0xd9, 0xa8, - 0x33, 0x0e, 0xc9, 0x0e, 0xf6, 0x2b, 0x9b, 0x8d, 0x7a, 0x33, 0x97, 0x14, 0x21, 0xe3, 0x2c, 0x06, - 0x5d, 0xec, 0x5c, 0xd3, 0x35, 0x9c, 0x1b, 0xa0, 0x0c, 0xee, 0x6d, 0x61, 0xb0, 0xce, 0xfa, 0x9b, - 0x79, 0x08, 0x3a, 0x34, 0x07, 0x69, 0xbc, 0xeb, 0x61, 0xd3, 0xd5, 0x2d, 0x33, 0x37, 0x48, 0x99, - 0xbc, 0xab, 0xcd, 0x2c, 0x62, 0xa3, 0xda, 0xcc, 0x22, 0xa0, 0x43, 0x67, 0x61, 0xd0, 0xb2, 0x3d, - 0xdd, 0x32, 0xdd, 0x5c, 0xea, 0x84, 0x74, 0x32, 0x73, 0xfa, 0x58, 0x5b, 0x47, 0x58, 0x65, 0x38, - 0x8a, 0x40, 0x46, 0x8b, 0x90, 0x75, 0xad, 0x86, 0xa3, 0xe1, 0x8a, 0x66, 0x55, 0x71, 0x45, 0x37, - 0xb7, 0xad, 0x5c, 0x9a, 0x32, 0x98, 0x6e, 0x55, 0x84, 0x22, 0xce, 0x59, 0x55, 0xbc, 0x68, 0x6e, - 0x5b, 0xca, 0x88, 0x1b, 0x69, 0xa3, 0x49, 0x18, 0x70, 0xf7, 0x4c, 0x4f, 0xdd, 0xcd, 0x0d, 0x51, - 0x0f, 0xe1, 0x2d, 0xf9, 0xd7, 0x06, 0x60, 0xb4, 0x17, 0x17, 0x3b, 0x0f, 0xc9, 0x6d, 0xa2, 0x65, - 0x2e, 0xd6, 0x8f, 0x0d, 0x18, 0x4d, 0xd4, 0x88, 0x03, 0x07, 0x34, 0xe2, 0x2c, 0x64, 0x4c, 0xec, - 0x7a, 0xb8, 0xca, 0x3c, 0x22, 0xde, 0xa3, 0x4f, 0x01, 0x23, 0x6a, 0x75, 0xa9, 0xc4, 0x81, 0x5c, - 0xea, 0x69, 0x18, 0xf5, 0x45, 0xaa, 0x38, 0xaa, 0x59, 0x13, 0xbe, 0x39, 0xd3, 0x4d, 0x92, 0x42, - 0x59, 0xd0, 0x29, 0x84, 0x4c, 0x19, 0xc1, 0x91, 0x36, 0x9a, 0x07, 0xb0, 0x4c, 0x6c, 0x6d, 0x57, - 0xaa, 0x58, 0x33, 0x72, 0xa9, 0x0e, 0x56, 0x5a, 0x25, 0x28, 0x2d, 0x56, 0xb2, 0x18, 0x54, 0x33, - 0xd0, 0xe3, 0x81, 0xab, 0x0d, 0x76, 0xf0, 0x94, 0x65, 0x16, 0x64, 0x2d, 0xde, 0xb6, 0x09, 0x23, - 0x0e, 0x26, 0x7e, 0x8f, 0xab, 0x5c, 0xb3, 0x34, 0x15, 0xa2, 0xd0, 0x55, 0x33, 0x85, 0x93, 0x31, - 0xc5, 0x86, 0x9d, 0x70, 0x13, 0xdd, 0x05, 0x3e, 0xa0, 0x42, 0xdd, 0x0a, 0x68, 0x16, 0x1a, 0x12, - 0xc0, 0x15, 0xb5, 0x8e, 0xf3, 0x37, 0x60, 0x24, 0x6a, 0x1e, 0x34, 0x01, 0x49, 0xd7, 0x53, 0x1d, - 0x8f, 0x7a, 0x61, 0x52, 0x61, 0x0d, 0x94, 0x85, 0x38, 0x36, 0xab, 0x34, 0xcb, 0x25, 0x15, 0xf2, - 0x13, 0xbd, 0x2f, 0x50, 0x38, 0x4e, 0x15, 0xbe, 0xa7, 0x75, 0x46, 0x23, 0x9c, 0x9b, 0xf5, 0xce, - 0x3f, 0x06, 0xc3, 0x11, 0x05, 0x7a, 0x1d, 0x5a, 0xfe, 0x30, 0x1c, 0x6e, 0xcb, 0x1a, 0x3d, 0x0d, - 0x13, 0x0d, 0x53, 0x37, 0x3d, 0xec, 0xd8, 0x0e, 0x26, 0x1e, 0xcb, 0x86, 0xca, 0xfd, 0x97, 0xc1, - 0x0e, 0x3e, 0xb7, 0x19, 0xc6, 0x66, 0x5c, 0x94, 0xf1, 0x46, 0x2b, 0xf0, 0x54, 0x3a, 0xf5, 0xdd, - 0xc1, 0xec, 0x73, 0xcf, 0x3d, 0xf7, 0x5c, 0x4c, 0x7e, 0x61, 0x00, 0x26, 0xda, 0xc5, 0x4c, 0xdb, - 0xf0, 0x9d, 0x84, 0x01, 0xb3, 0x51, 0xdf, 0xc2, 0x0e, 0x35, 0x52, 0x52, 0xe1, 0x2d, 0x34, 0x0b, - 0x49, 0x43, 0xdd, 0xc2, 0x46, 0x2e, 0x71, 0x42, 0x3a, 0x39, 0x72, 0xfa, 0xfe, 0x9e, 0xa2, 0xb2, - 0xb0, 0x44, 0x48, 0x14, 0x46, 0x89, 0xde, 0x0b, 0x09, 0x9e, 0xa2, 0x09, 0x87, 0x53, 0xbd, 0x71, - 0x20, 0xb1, 0xa4, 0x50, 0x3a, 0x74, 0x14, 0xd2, 0xe4, 0x2f, 0xf3, 0x8d, 0x01, 0x2a, 0x73, 0x8a, - 0x00, 0x88, 0x5f, 0xa0, 0x3c, 0xa4, 0x68, 0x98, 0x54, 0xb1, 0x58, 0xda, 0xfc, 0x36, 0x71, 0xac, - 0x2a, 0xde, 0x56, 0x1b, 0x86, 0x57, 0xb9, 0xa6, 0x1a, 0x0d, 0x4c, 0x1d, 0x3e, 0xad, 0x0c, 0x71, - 0xe0, 0x15, 0x02, 0x43, 0xd3, 0x90, 0x61, 0x51, 0xa5, 0x9b, 0x55, 0xbc, 0x4b, 0xb3, 0x67, 0x52, - 0x61, 0x81, 0xb6, 0x48, 0x20, 0x64, 0xf8, 0x67, 0x5c, 0xcb, 0x14, 0xae, 0x49, 0x87, 0x20, 0x00, - 0x3a, 0xfc, 0x63, 0xcd, 0x89, 0xfb, 0x78, 0x7b, 0xf5, 0x9a, 0x7d, 0x4a, 0xfe, 0xd5, 0x18, 0x24, - 0x68, 0xbe, 0x18, 0x85, 0xcc, 0xc6, 0xfb, 0xd7, 0xca, 0x95, 0xf9, 0xd5, 0xcd, 0xd2, 0x52, 0x39, - 0x2b, 0xa1, 0x11, 0x00, 0x0a, 0xb8, 0xb0, 0xb4, 0x3a, 0xbb, 0x91, 0x8d, 0xf9, 0xed, 0xc5, 0x95, - 0x8d, 0xb3, 0x67, 0xb2, 0x71, 0x9f, 0x60, 0x93, 0x01, 0x12, 0x61, 0x84, 0x47, 0x4e, 0x67, 0x93, - 0x28, 0x0b, 0x43, 0x8c, 0xc1, 0xe2, 0xd3, 0xe5, 0xf9, 0xb3, 0x67, 0xb2, 0x03, 0x51, 0xc8, 0x23, - 0xa7, 0xb3, 0x83, 0x68, 0x18, 0xd2, 0x14, 0x52, 0x5a, 0x5d, 0x5d, 0xca, 0xa6, 0x7c, 0x9e, 0xeb, - 0x1b, 0xca, 0xe2, 0xca, 0x42, 0x36, 0xed, 0xf3, 0x5c, 0x50, 0x56, 0x37, 0xd7, 0xb2, 0xe0, 0x73, - 0x58, 0x2e, 0xaf, 0xaf, 0xcf, 0x2e, 0x94, 0xb3, 0x19, 0x1f, 0xa3, 0xf4, 0xfe, 0x8d, 0xf2, 0x7a, - 0x76, 0x28, 0x22, 0xd6, 0x23, 0xa7, 0xb3, 0xc3, 0xfe, 0x10, 0xe5, 0x95, 0xcd, 0xe5, 0xec, 0x08, - 0x1a, 0x83, 0x61, 0x36, 0x84, 0x10, 0x62, 0xb4, 0x09, 0x74, 0xf6, 0x4c, 0x36, 0x1b, 0x08, 0xc2, - 0xb8, 0x8c, 0x45, 0x00, 0x67, 0xcf, 0x64, 0x91, 0x3c, 0x07, 0x49, 0xea, 0x5d, 0x08, 0xc1, 0xc8, - 0xd2, 0x6c, 0xa9, 0xbc, 0x54, 0x59, 0x5d, 0xdb, 0x58, 0x5c, 0x5d, 0x99, 0x5d, 0xca, 0x4a, 0x01, - 0x4c, 0x29, 0x3f, 0xb9, 0xb9, 0xa8, 0x94, 0xe7, 0xb3, 0xb1, 0x30, 0x6c, 0xad, 0x3c, 0xbb, 0x51, - 0x9e, 0xcf, 0xc6, 0x65, 0x0d, 0x26, 0xda, 0xe5, 0xc9, 0xb6, 0x91, 0x11, 0x9a, 0xe2, 0x58, 0x87, - 0x29, 0xa6, 0xbc, 0x5a, 0xa6, 0xf8, 0xdb, 0x31, 0x18, 0x6f, 0xb3, 0x56, 0xb4, 0x1d, 0xe4, 0x09, - 0x48, 0x32, 0x17, 0x65, 0xab, 0xe7, 0x7d, 0x6d, 0x17, 0x1d, 0xea, 0xb0, 0x2d, 0x2b, 0x28, 0xa5, - 0x0b, 0x57, 0x10, 0xf1, 0x0e, 0x15, 0x04, 0x61, 0xd1, 0x92, 0xd3, 0x7f, 0xb4, 0x25, 0xa7, 0xb3, - 0x65, 0xef, 0x6c, 0x2f, 0xcb, 0x1e, 0x85, 0xf5, 0x97, 0xdb, 0x93, 0x6d, 0x72, 0xfb, 0x79, 0x18, - 0x6b, 0x61, 0xd4, 0x73, 0x8e, 0xfd, 0xa8, 0x04, 0xb9, 0x4e, 0xc6, 0xe9, 0x92, 0xe9, 0x62, 0x91, - 0x4c, 0x77, 0xbe, 0xd9, 0x82, 0x77, 0x76, 0x9e, 0x84, 0x96, 0xb9, 0xfe, 0xb2, 0x04, 0x93, 0xed, - 0x2b, 0xc5, 0xb6, 0x32, 0xbc, 0x17, 0x06, 0xea, 0xd8, 0xdb, 0xb1, 0x44, 0xb5, 0x74, 0x4f, 0x9b, - 0x35, 0x98, 0x74, 0x37, 0x4f, 0x36, 0xa7, 0x0a, 0x2f, 0xe2, 0xf1, 0x4e, 0xe5, 0x1e, 0x93, 0xa6, - 0x45, 0xd2, 0x4f, 0xc6, 0xe0, 0x70, 0x5b, 0xe6, 0x6d, 0x05, 0x3d, 0x0e, 0xa0, 0x9b, 0x76, 0xc3, - 0x63, 0x15, 0x11, 0x4b, 0xb0, 0x69, 0x0a, 0xa1, 0xc9, 0x8b, 0x24, 0xcf, 0x86, 0xe7, 0xf7, 0xc7, - 0x69, 0x3f, 0x30, 0x10, 0x45, 0x38, 0x17, 0x08, 0x9a, 0xa0, 0x82, 0x4e, 0x75, 0xd0, 0xb4, 0xc5, - 0x31, 0x1f, 0x82, 0xac, 0x66, 0xe8, 0xd8, 0xf4, 0x2a, 0xae, 0xe7, 0x60, 0xb5, 0xae, 0x9b, 0x35, - 0xba, 0x82, 0xa4, 0x8a, 0xc9, 0x6d, 0xd5, 0x70, 0xb1, 0x32, 0xca, 0xba, 0xd7, 0x45, 0x2f, 0xa1, - 0xa0, 0x0e, 0xe4, 0x84, 0x28, 0x06, 0x22, 0x14, 0xac, 0xdb, 0xa7, 0x90, 0x7f, 0x3a, 0x0d, 0x99, - 0x50, 0x5d, 0x8d, 0xee, 0x84, 0xa1, 0x67, 0xd4, 0x6b, 0x6a, 0x45, 0xec, 0x95, 0x98, 0x25, 0x32, - 0x04, 0xb6, 0xc6, 0xf7, 0x4b, 0x0f, 0xc1, 0x04, 0x45, 0xb1, 0x1a, 0x1e, 0x76, 0x2a, 0x9a, 0xa1, - 0xba, 0x2e, 0x35, 0x5a, 0x8a, 0xa2, 0x22, 0xd2, 0xb7, 0x4a, 0xba, 0xe6, 0x44, 0x0f, 0x7a, 0x14, - 0xc6, 0x29, 0x45, 0xbd, 0x61, 0x78, 0xba, 0x6d, 0xe0, 0x0a, 0xd9, 0xbd, 0xb9, 0x74, 0x25, 0xf1, - 0x25, 0x1b, 0x23, 0x18, 0xcb, 0x1c, 0x81, 0x48, 0xe4, 0xa2, 0x79, 0x38, 0x4e, 0xc9, 0x6a, 0xd8, - 0xc4, 0x8e, 0xea, 0xe1, 0x0a, 0x7e, 0xb6, 0xa1, 0x1a, 0x6e, 0x45, 0x35, 0xab, 0x95, 0x1d, 0xd5, - 0xdd, 0xc9, 0x4d, 0x10, 0x06, 0xa5, 0x58, 0x4e, 0x52, 0x8e, 0x10, 0xc4, 0x05, 0x8e, 0x57, 0xa6, - 0x68, 0xb3, 0x66, 0xf5, 0xa2, 0xea, 0xee, 0xa0, 0x22, 0x4c, 0x52, 0x2e, 0xae, 0xe7, 0xe8, 0x66, - 0xad, 0xa2, 0xed, 0x60, 0xed, 0x6a, 0xa5, 0xe1, 0x6d, 0x9f, 0xcb, 0x1d, 0x0d, 0x8f, 0x4f, 0x25, - 0x5c, 0xa7, 0x38, 0x73, 0x04, 0x65, 0xd3, 0xdb, 0x3e, 0x87, 0xd6, 0x61, 0x88, 0x4c, 0x46, 0x5d, - 0xbf, 0x81, 0x2b, 0xdb, 0x96, 0x43, 0x97, 0xc6, 0x91, 0x36, 0xa9, 0x29, 0x64, 0xc1, 0xc2, 0x2a, - 0x27, 0x58, 0xb6, 0xaa, 0xb8, 0x98, 0x5c, 0x5f, 0x2b, 0x97, 0xe7, 0x95, 0x8c, 0xe0, 0x72, 0xc1, - 0x72, 0x88, 0x43, 0xd5, 0x2c, 0xdf, 0xc0, 0x19, 0xe6, 0x50, 0x35, 0x4b, 0x98, 0xf7, 0x51, 0x18, - 0xd7, 0x34, 0xa6, 0xb3, 0xae, 0x55, 0xf8, 0x1e, 0xcb, 0xcd, 0x65, 0x23, 0xc6, 0xd2, 0xb4, 0x05, - 0x86, 0xc0, 0x7d, 0xdc, 0x45, 0x8f, 0xc3, 0xe1, 0xc0, 0x58, 0x61, 0xc2, 0xb1, 0x16, 0x2d, 0x9b, - 0x49, 0x1f, 0x85, 0x71, 0x7b, 0xaf, 0x95, 0x10, 0x45, 0x46, 0xb4, 0xf7, 0x9a, 0xc9, 0x1e, 0x83, - 0x09, 0x7b, 0xc7, 0x6e, 0xa5, 0x3b, 0x15, 0xa6, 0x43, 0xf6, 0x8e, 0xdd, 0x4c, 0xf8, 0x2e, 0xba, - 0xe1, 0x76, 0xb0, 0xa6, 0x7a, 0xb8, 0x9a, 0xbb, 0x23, 0x8c, 0x1e, 0xea, 0x40, 0x33, 0x90, 0xd5, - 0xb4, 0x0a, 0x36, 0xd5, 0x2d, 0x03, 0x57, 0x54, 0x07, 0x9b, 0xaa, 0x9b, 0x9b, 0x0e, 0x23, 0x8f, - 0x68, 0x5a, 0x99, 0xf6, 0xce, 0xd2, 0x4e, 0x74, 0x0a, 0xc6, 0xac, 0xad, 0x67, 0x34, 0xe6, 0x92, - 0x15, 0xdb, 0xc1, 0xdb, 0xfa, 0x6e, 0xee, 0x6e, 0x6a, 0xdf, 0x51, 0xd2, 0x41, 0x1d, 0x72, 0x8d, - 0x82, 0xd1, 0x7d, 0x90, 0xd5, 0xdc, 0x1d, 0xd5, 0xb1, 0x69, 0x4e, 0x76, 0x6d, 0x55, 0xc3, 0xb9, - 0x77, 0x31, 0x54, 0x06, 0x5f, 0x11, 0x60, 0x12, 0x12, 0xee, 0x75, 0x7d, 0xdb, 0x13, 0x1c, 0xef, - 0x65, 0x21, 0x41, 0x61, 0x9c, 0xdb, 0x49, 0xc8, 0x12, 0x53, 0x44, 0x06, 0x3e, 0x49, 0xd1, 0x46, - 0xec, 0x1d, 0x3b, 0x3c, 0xee, 0x5d, 0x30, 0x4c, 0x30, 0x83, 0x41, 0xef, 0x63, 0x05, 0x99, 0xbd, - 0x13, 0x1a, 0xf1, 0x0c, 0x4c, 0x12, 0xa4, 0x3a, 0xf6, 0xd4, 0xaa, 0xea, 0xa9, 0x21, 0xec, 0x07, - 0x28, 0x36, 0xb1, 0xfb, 0x32, 0xef, 0x8c, 0xc8, 0xe9, 0x34, 0xb6, 0xf6, 0x7c, 0xcf, 0x7a, 0x90, - 0xc9, 0x49, 0x60, 0xc2, 0xb7, 0xde, 0xb4, 0xa2, 0x5b, 0x2e, 0xc2, 0x50, 0xd8, 0xf1, 0x51, 0x1a, - 0x98, 0xeb, 0x67, 0x25, 0x52, 0x05, 0xcd, 0xad, 0xce, 0x93, 0xfa, 0xe5, 0x03, 0xe5, 0x6c, 0x8c, - 0xd4, 0x51, 0x4b, 0x8b, 0x1b, 0xe5, 0x8a, 0xb2, 0xb9, 0xb2, 0xb1, 0xb8, 0x5c, 0xce, 0xc6, 0x43, - 0x05, 0xfb, 0xa5, 0x44, 0xea, 0x9e, 0xec, 0xbd, 0xf2, 0x2b, 0x31, 0x18, 0x89, 0xee, 0xc0, 0xd0, - 0xbb, 0xe1, 0x0e, 0x71, 0x5c, 0xe2, 0x62, 0xaf, 0x72, 0x5d, 0x77, 0x68, 0x44, 0xd6, 0x55, 0xb6, - 0x3a, 0xfa, 0x3e, 0x31, 0xc1, 0xb1, 0xd6, 0xb1, 0xf7, 0x94, 0xee, 0x90, 0x78, 0xab, 0xab, 0x1e, - 0x5a, 0x82, 0x69, 0xd3, 0xaa, 0xb8, 0x9e, 0x6a, 0x56, 0x55, 0xa7, 0x5a, 0x09, 0x0e, 0xaa, 0x2a, - 0xaa, 0xa6, 0x61, 0xd7, 0xb5, 0xd8, 0x4a, 0xe8, 0x73, 0x39, 0x66, 0x5a, 0xeb, 0x1c, 0x39, 0x58, - 0x22, 0x66, 0x39, 0x6a, 0x93, 0xff, 0xc6, 0x3b, 0xf9, 0xef, 0x51, 0x48, 0xd7, 0x55, 0xbb, 0x82, - 0x4d, 0xcf, 0xd9, 0xa3, 0x75, 0x77, 0x4a, 0x49, 0xd5, 0x55, 0xbb, 0x4c, 0xda, 0x6f, 0xc9, 0xf6, - 0xe7, 0x52, 0x22, 0x95, 0xca, 0xa6, 0x2f, 0x25, 0x52, 0xe9, 0x2c, 0xc8, 0xaf, 0xc6, 0x61, 0x28, - 0x5c, 0x87, 0x93, 0x6d, 0x8d, 0x46, 0x97, 0x2c, 0x89, 0x26, 0xb5, 0xbb, 0xf6, 0xad, 0xda, 0x0b, - 0x73, 0x64, 0x2d, 0x2b, 0x0e, 0xb0, 0xea, 0x58, 0x61, 0x94, 0xa4, 0x8e, 0x20, 0xce, 0x86, 0x59, - 0x35, 0x92, 0x52, 0x78, 0x0b, 0x2d, 0xc0, 0xc0, 0x33, 0x2e, 0xe5, 0x3d, 0x40, 0x79, 0xdf, 0xbd, - 0x3f, 0xef, 0x4b, 0xeb, 0x94, 0x79, 0xfa, 0xd2, 0x7a, 0x65, 0x65, 0x55, 0x59, 0x9e, 0x5d, 0x52, - 0x38, 0x39, 0x3a, 0x02, 0x09, 0x43, 0xbd, 0xb1, 0x17, 0x5d, 0xf5, 0x28, 0xa8, 0xd7, 0x49, 0x38, - 0x02, 0x89, 0xeb, 0x58, 0xbd, 0x1a, 0x5d, 0x6b, 0x28, 0xe8, 0x4d, 0x0c, 0x86, 0x19, 0x48, 0x52, - 0x7b, 0x21, 0x00, 0x6e, 0xb1, 0xec, 0x21, 0x94, 0x82, 0xc4, 0xdc, 0xaa, 0x42, 0x02, 0x22, 0x0b, - 0x43, 0x0c, 0x5a, 0x59, 0x5b, 0x2c, 0xcf, 0x95, 0xb3, 0x31, 0xf9, 0x51, 0x18, 0x60, 0x46, 0x20, - 0xc1, 0xe2, 0x9b, 0x21, 0x7b, 0x88, 0x37, 0x39, 0x0f, 0x49, 0xf4, 0x6e, 0x2e, 0x97, 0xca, 0x4a, - 0x36, 0x16, 0x9d, 0xea, 0x44, 0x36, 0x29, 0xbb, 0x30, 0x14, 0x2e, 0xc4, 0xdf, 0x9a, 0x4d, 0xf6, - 0xd7, 0x24, 0xc8, 0x84, 0x0a, 0x6b, 0x52, 0x11, 0xa9, 0x86, 0x61, 0x5d, 0xaf, 0xa8, 0x86, 0xae, - 0xba, 0xdc, 0x35, 0x80, 0x82, 0x66, 0x09, 0xa4, 0xd7, 0xa9, 0x7b, 0x8b, 0x42, 0x24, 0x99, 0x1d, - 0x90, 0x3f, 0x2f, 0x41, 0xb6, 0xb9, 0xb2, 0x6d, 0x12, 0x53, 0xfa, 0x41, 0x8a, 0x29, 0x7f, 0x4e, - 0x82, 0x91, 0x68, 0x39, 0xdb, 0x24, 0xde, 0x9d, 0x3f, 0x50, 0xf1, 0xfe, 0x20, 0x06, 0xc3, 0x91, - 0x22, 0xb6, 0x57, 0xe9, 0x9e, 0x85, 0x31, 0xbd, 0x8a, 0xeb, 0xb6, 0xe5, 0x61, 0x53, 0xdb, 0xab, - 0x18, 0xf8, 0x1a, 0x36, 0x72, 0x32, 0x4d, 0x1a, 0x33, 0xfb, 0x97, 0xc9, 0x85, 0xc5, 0x80, 0x6e, - 0x89, 0x90, 0x15, 0xc7, 0x17, 0xe7, 0xcb, 0xcb, 0x6b, 0xab, 0x1b, 0xe5, 0x95, 0xb9, 0xf7, 0x57, - 0x36, 0x57, 0x2e, 0xaf, 0xac, 0x3e, 0xb5, 0xa2, 0x64, 0xf5, 0x26, 0xb4, 0x37, 0x31, 0xec, 0xd7, - 0x20, 0xdb, 0x2c, 0x14, 0xba, 0x03, 0xda, 0x89, 0x95, 0x3d, 0x84, 0xc6, 0x61, 0x74, 0x65, 0xb5, - 0xb2, 0xbe, 0x38, 0x5f, 0xae, 0x94, 0x2f, 0x5c, 0x28, 0xcf, 0x6d, 0xac, 0xb3, 0x83, 0x0f, 0x1f, - 0x7b, 0x23, 0x12, 0xe0, 0xf2, 0x67, 0xe3, 0x30, 0xde, 0x46, 0x12, 0x34, 0xcb, 0xb7, 0x2c, 0x6c, - 0x17, 0xf5, 0x60, 0x2f, 0xd2, 0x17, 0x48, 0xcd, 0xb0, 0xa6, 0x3a, 0x1e, 0xdf, 0xe1, 0xdc, 0x07, - 0xc4, 0x4a, 0xa6, 0xa7, 0x6f, 0xeb, 0xd8, 0xe1, 0xe7, 0x44, 0x6c, 0x1f, 0x33, 0x1a, 0xc0, 0xd9, - 0x51, 0xd1, 0x03, 0x80, 0x6c, 0xcb, 0xd5, 0x3d, 0xfd, 0x1a, 0xae, 0xe8, 0xa6, 0x38, 0x54, 0x22, - 0xfb, 0x9a, 0x84, 0x92, 0x15, 0x3d, 0x8b, 0xa6, 0xe7, 0x63, 0x9b, 0xb8, 0xa6, 0x36, 0x61, 0x93, - 0x64, 0x1e, 0x57, 0xb2, 0xa2, 0xc7, 0xc7, 0xbe, 0x13, 0x86, 0xaa, 0x56, 0x83, 0x14, 0x7b, 0x0c, - 0x8f, 0xac, 0x1d, 0x92, 0x92, 0x61, 0x30, 0x1f, 0x85, 0x97, 0xf1, 0xc1, 0x69, 0xd6, 0x90, 0x92, - 0x61, 0x30, 0x86, 0x72, 0x2f, 0x8c, 0xaa, 0xb5, 0x9a, 0x43, 0x98, 0x0b, 0x46, 0x6c, 0x63, 0x32, - 0xe2, 0x83, 0x29, 0x62, 0xfe, 0x12, 0xa4, 0x84, 0x1d, 0xc8, 0x52, 0x4d, 0x2c, 0x51, 0xb1, 0xd9, - 0x6e, 0x3b, 0x76, 0x32, 0xad, 0xa4, 0x4c, 0xd1, 0x79, 0x27, 0x0c, 0xe9, 0x6e, 0x25, 0x38, 0x9c, - 0x8f, 0x9d, 0x88, 0x9d, 0x4c, 0x29, 0x19, 0xdd, 0xf5, 0x0f, 0x36, 0xe5, 0x2f, 0xc7, 0x60, 0x24, - 0xfa, 0x70, 0x01, 0xcd, 0x43, 0xca, 0xb0, 0x34, 0x95, 0xba, 0x16, 0x7b, 0xb2, 0x75, 0xb2, 0xcb, - 0xf3, 0x88, 0xc2, 0x12, 0xc7, 0x57, 0x7c, 0xca, 0xfc, 0xbf, 0x92, 0x20, 0x25, 0xc0, 0x68, 0x12, - 0x12, 0xb6, 0xea, 0xed, 0x50, 0x76, 0xc9, 0x52, 0x2c, 0x2b, 0x29, 0xb4, 0x4d, 0xe0, 0xae, 0xad, - 0x9a, 0xd4, 0x05, 0x38, 0x9c, 0xb4, 0xc9, 0xbc, 0x1a, 0x58, 0xad, 0xd2, 0x5d, 0x8f, 0x55, 0xaf, - 0x63, 0xd3, 0x73, 0xc5, 0xbc, 0x72, 0xf8, 0x1c, 0x07, 0xa3, 0xfb, 0x61, 0xcc, 0x73, 0x54, 0xdd, - 0x88, 0xe0, 0x26, 0x28, 0x6e, 0x56, 0x74, 0xf8, 0xc8, 0x45, 0x38, 0x22, 0xf8, 0x56, 0xb1, 0xa7, - 0x6a, 0x3b, 0xb8, 0x1a, 0x10, 0x0d, 0xd0, 0xd3, 0x8d, 0x3b, 0x38, 0xc2, 0x3c, 0xef, 0x17, 0xb4, - 0xf2, 0x2b, 0x12, 0x8c, 0x89, 0x7d, 0x5a, 0xd5, 0x37, 0xd6, 0x32, 0x80, 0x6a, 0x9a, 0x96, 0x17, - 0x36, 0x57, 0xab, 0x2b, 0xb7, 0xd0, 0x15, 0x66, 0x7d, 0x22, 0x25, 0xc4, 0x20, 0x5f, 0x07, 0x08, - 0x7a, 0x3a, 0x9a, 0x6d, 0x1a, 0x32, 0xfc, 0xc9, 0x11, 0x7d, 0xfc, 0xc8, 0x76, 0xf6, 0xc0, 0x40, - 0x64, 0x43, 0x87, 0x26, 0x20, 0xb9, 0x85, 0x6b, 0xba, 0xc9, 0xcf, 0x83, 0x59, 0x43, 0x9c, 0xbf, - 0x24, 0xfc, 0xf3, 0x97, 0xd2, 0xa7, 0x24, 0x18, 0xd7, 0xac, 0x7a, 0xb3, 0xbc, 0xa5, 0x6c, 0xd3, - 0xf1, 0x82, 0x7b, 0x51, 0xfa, 0xc0, 0x7b, 0x6b, 0xba, 0xb7, 0xd3, 0xd8, 0x2a, 0x68, 0x56, 0x7d, - 0xa6, 0x66, 0x19, 0xaa, 0x59, 0x0b, 0x9e, 0x9f, 0xd2, 0x1f, 0xda, 0x83, 0x35, 0x6c, 0x3e, 0x58, - 0xb3, 0x42, 0x4f, 0x53, 0xcf, 0x07, 0x3f, 0xff, 0xaf, 0x24, 0x7d, 0x31, 0x16, 0x5f, 0x58, 0x2b, - 0x7d, 0x25, 0x96, 0x5f, 0x60, 0xc3, 0xad, 0x09, 0xf3, 0x28, 0x78, 0xdb, 0xc0, 0x1a, 0x51, 0x19, - 0xbe, 0x77, 0x3f, 0x4c, 0xd4, 0xac, 0x9a, 0x45, 0x39, 0xce, 0x90, 0x5f, 0xfc, 0x89, 0x6c, 0xda, - 0x87, 0xe6, 0xbb, 0x3e, 0xbe, 0x2d, 0xae, 0xc0, 0x38, 0x47, 0xae, 0xd0, 0x47, 0x42, 0x6c, 0x63, - 0x83, 0xf6, 0x3d, 0x56, 0xcb, 0xfd, 0xf2, 0x77, 0xe8, 0x82, 0xae, 0x8c, 0x71, 0x52, 0xd2, 0xc7, - 0xf6, 0x3e, 0x45, 0x05, 0x0e, 0x47, 0xf8, 0xb1, 0xb0, 0xc5, 0x4e, 0x17, 0x8e, 0xbf, 0xc9, 0x39, - 0x8e, 0x87, 0x38, 0xae, 0x73, 0xd2, 0xe2, 0x1c, 0x0c, 0xf7, 0xc3, 0xeb, 0xb7, 0x38, 0xaf, 0x21, - 0x1c, 0x66, 0xb2, 0x00, 0xa3, 0x94, 0x89, 0xd6, 0x70, 0x3d, 0xab, 0x4e, 0x73, 0xe2, 0xfe, 0x6c, - 0x7e, 0xfb, 0x3b, 0x2c, 0x8e, 0x46, 0x08, 0xd9, 0x9c, 0x4f, 0x55, 0x2c, 0x02, 0x7d, 0x0a, 0x56, - 0xc5, 0x9a, 0xd1, 0x85, 0xc3, 0x37, 0xb8, 0x20, 0x3e, 0x7e, 0xf1, 0x0a, 0x4c, 0x90, 0xdf, 0x34, - 0x65, 0x85, 0x25, 0xe9, 0x7e, 0x06, 0x97, 0x7b, 0xe5, 0xa3, 0x2c, 0x54, 0xc7, 0x7d, 0x06, 0x21, - 0x99, 0x42, 0xb3, 0x58, 0xc3, 0x9e, 0x87, 0x1d, 0xb7, 0xa2, 0x1a, 0xed, 0xc4, 0x0b, 0x1d, 0x62, - 0xe4, 0x3e, 0xf3, 0xfd, 0xe8, 0x2c, 0x2e, 0x30, 0xca, 0x59, 0xc3, 0x28, 0x6e, 0xc2, 0x1d, 0x6d, - 0xbc, 0xa2, 0x07, 0x9e, 0x9f, 0xe5, 0x3c, 0x27, 0x5a, 0x3c, 0x83, 0xb0, 0x5d, 0x03, 0x01, 0xf7, - 0xe7, 0xb2, 0x07, 0x9e, 0x3f, 0xc7, 0x79, 0x22, 0x4e, 0x2b, 0xa6, 0x94, 0x70, 0xbc, 0x04, 0x63, - 0xd7, 0xb0, 0xb3, 0x65, 0xb9, 0xfc, 0xe0, 0xa8, 0x07, 0x76, 0x9f, 0xe3, 0xec, 0x46, 0x39, 0x21, - 0x3d, 0x49, 0x22, 0xbc, 0x1e, 0x87, 0xd4, 0xb6, 0xaa, 0xe1, 0x1e, 0x58, 0xbc, 0xc8, 0x59, 0x0c, - 0x12, 0x7c, 0x42, 0x3a, 0x0b, 0x43, 0x35, 0x8b, 0xaf, 0x5a, 0xdd, 0xc9, 0x3f, 0xcf, 0xc9, 0x33, - 0x82, 0x86, 0xb3, 0xb0, 0x2d, 0xbb, 0x61, 0x90, 0x25, 0xad, 0x3b, 0x8b, 0xbf, 0x2a, 0x58, 0x08, - 0x1a, 0xce, 0xa2, 0x0f, 0xb3, 0xbe, 0x24, 0x58, 0xb8, 0x21, 0x7b, 0x3e, 0x01, 0x19, 0xcb, 0x34, - 0xf6, 0x2c, 0xb3, 0x17, 0x21, 0xbe, 0xc0, 0x39, 0x00, 0x27, 0x21, 0x0c, 0xce, 0x43, 0xba, 0xd7, - 0x89, 0xf8, 0xeb, 0xdf, 0x17, 0xe1, 0x21, 0x66, 0x60, 0x01, 0x46, 0x45, 0x82, 0xd2, 0x2d, 0xb3, - 0x07, 0x16, 0x7f, 0x83, 0xb3, 0x18, 0x09, 0x91, 0x71, 0x35, 0x3c, 0xec, 0x7a, 0x35, 0xdc, 0x0b, - 0x93, 0x2f, 0x0b, 0x35, 0x38, 0x09, 0x37, 0xe5, 0x16, 0x36, 0xb5, 0x9d, 0xde, 0x38, 0xfc, 0xbc, - 0x30, 0xa5, 0xa0, 0x21, 0x2c, 0xe6, 0x60, 0xb8, 0xae, 0x3a, 0xee, 0x8e, 0x6a, 0xf4, 0x34, 0x1d, - 0x7f, 0x93, 0xf3, 0x18, 0xf2, 0x89, 0xb8, 0x45, 0x1a, 0x66, 0x3f, 0x6c, 0xbe, 0x22, 0x2c, 0x12, - 0x22, 0xe3, 0xa1, 0xe7, 0x7a, 0xf4, 0x94, 0xad, 0x1f, 0x6e, 0xbf, 0x20, 0x42, 0x8f, 0xd1, 0x2e, - 0x87, 0x39, 0x9e, 0x87, 0xb4, 0xab, 0xdf, 0xe8, 0x89, 0xcd, 0xdf, 0x12, 0x33, 0x4d, 0x09, 0x08, - 0xf1, 0xfb, 0xe1, 0x48, 0xdb, 0x65, 0xa2, 0x07, 0x66, 0x7f, 0x9b, 0x33, 0x9b, 0x6c, 0xb3, 0x54, - 0xf0, 0x94, 0xd0, 0x2f, 0xcb, 0xbf, 0x23, 0x52, 0x02, 0x6e, 0xe2, 0xb5, 0x46, 0xf6, 0x11, 0xae, - 0xba, 0xdd, 0x9f, 0xd5, 0x7e, 0x51, 0x58, 0x8d, 0xd1, 0x46, 0xac, 0xb6, 0x01, 0x93, 0x9c, 0x63, - 0x7f, 0xf3, 0xfa, 0x4b, 0x22, 0xb1, 0x32, 0xea, 0xcd, 0xe8, 0xec, 0x7e, 0x10, 0xf2, 0xbe, 0x39, - 0x45, 0xc1, 0xea, 0x56, 0xea, 0xaa, 0xdd, 0x03, 0xe7, 0x5f, 0xe6, 0x9c, 0x45, 0xc6, 0xf7, 0x2b, - 0x5e, 0x77, 0x59, 0xb5, 0x09, 0xf3, 0xa7, 0x21, 0x27, 0x98, 0x37, 0x4c, 0x07, 0x6b, 0x56, 0xcd, - 0xd4, 0x6f, 0xe0, 0x6a, 0x0f, 0xac, 0xff, 0x6e, 0xd3, 0x54, 0x6d, 0x86, 0xc8, 0x09, 0xe7, 0x45, - 0xc8, 0xfa, 0xb5, 0x4a, 0x45, 0xaf, 0xdb, 0x96, 0xe3, 0x75, 0xe1, 0xf8, 0x55, 0x31, 0x53, 0x3e, - 0xdd, 0x22, 0x25, 0x2b, 0x96, 0x61, 0x84, 0x36, 0x7b, 0x75, 0xc9, 0x5f, 0xe1, 0x8c, 0x86, 0x03, - 0x2a, 0x9e, 0x38, 0x34, 0xab, 0x6e, 0xab, 0x4e, 0x2f, 0xf9, 0xef, 0xef, 0x89, 0xc4, 0xc1, 0x49, - 0x78, 0xe2, 0xf0, 0xf6, 0x6c, 0x4c, 0x56, 0xfb, 0x1e, 0x38, 0xfc, 0xaa, 0x48, 0x1c, 0x82, 0x86, - 0xb3, 0x10, 0x05, 0x43, 0x0f, 0x2c, 0xfe, 0xbe, 0x60, 0x21, 0x68, 0x08, 0x8b, 0x27, 0x83, 0x85, - 0xd6, 0xc1, 0x35, 0xdd, 0xf5, 0x1c, 0x56, 0x26, 0xef, 0xcf, 0xea, 0x1f, 0x7c, 0x3f, 0x5a, 0x84, - 0x29, 0x21, 0x52, 0x92, 0x89, 0xf8, 0xb1, 0x2b, 0xdd, 0x45, 0x75, 0x17, 0xec, 0xd7, 0x44, 0x26, - 0x0a, 0x91, 0x11, 0xd9, 0x42, 0x15, 0x22, 0x31, 0xbb, 0x46, 0xf6, 0x0e, 0x3d, 0xb0, 0xfb, 0x87, - 0x4d, 0xc2, 0xad, 0x0b, 0x5a, 0xc2, 0x33, 0x54, 0xff, 0x34, 0xcc, 0xab, 0x78, 0xaf, 0x27, 0xef, - 0xfc, 0xf5, 0xa6, 0xfa, 0x67, 0x93, 0x51, 0xb2, 0x1c, 0x32, 0xda, 0x54, 0x4f, 0xa1, 0x6e, 0xf7, - 0x87, 0x72, 0x3f, 0xf6, 0x1a, 0xd7, 0x37, 0x5a, 0x4e, 0x15, 0x97, 0x88, 0x93, 0x47, 0x8b, 0x9e, - 0xee, 0xcc, 0x3e, 0xfa, 0x9a, 0xef, 0xe7, 0x91, 0x9a, 0xa7, 0x78, 0x01, 0x86, 0x23, 0x05, 0x4f, - 0x77, 0x56, 0x1f, 0xe3, 0xac, 0x86, 0xc2, 0xf5, 0x4e, 0xf1, 0x51, 0x48, 0x90, 0xe2, 0xa5, 0x3b, - 0xf9, 0xc7, 0x39, 0x39, 0x45, 0x2f, 0xbe, 0x07, 0x52, 0xa2, 0x68, 0xe9, 0x4e, 0xfa, 0x09, 0x4e, - 0xea, 0x93, 0x10, 0x72, 0x51, 0xb0, 0x74, 0x27, 0xff, 0xf3, 0x82, 0x5c, 0x90, 0x10, 0xf2, 0xde, - 0x4d, 0xf8, 0xb5, 0xbf, 0x90, 0xe0, 0x8b, 0x8e, 0xb0, 0xdd, 0x79, 0x18, 0xe4, 0x95, 0x4a, 0x77, - 0xea, 0x4f, 0xf2, 0xc1, 0x05, 0x45, 0xf1, 0x31, 0x48, 0xf6, 0x68, 0xf0, 0x9f, 0xe4, 0xa4, 0x0c, - 0xbf, 0x38, 0x07, 0x99, 0x50, 0x75, 0xd2, 0x9d, 0xfc, 0x2f, 0x71, 0xf2, 0x30, 0x15, 0x11, 0x9d, - 0x57, 0x27, 0xdd, 0x19, 0x7c, 0x4a, 0x88, 0xce, 0x29, 0x88, 0xd9, 0x44, 0x61, 0xd2, 0x9d, 0xfa, - 0xd3, 0xc2, 0xea, 0x82, 0xa4, 0xf8, 0x04, 0xa4, 0xfd, 0xc5, 0xa6, 0x3b, 0xfd, 0x4f, 0x71, 0xfa, - 0x80, 0x86, 0x58, 0x20, 0xb4, 0xd8, 0x75, 0x67, 0xf1, 0xd3, 0xc2, 0x02, 0x21, 0x2a, 0x12, 0x46, - 0xcd, 0x05, 0x4c, 0x77, 0x4e, 0x3f, 0x23, 0xc2, 0xa8, 0xa9, 0x7e, 0x21, 0xb3, 0x49, 0x73, 0x7e, - 0x77, 0x16, 0x3f, 0x2b, 0x66, 0x93, 0xe2, 0x13, 0x31, 0x9a, 0x2b, 0x82, 0xee, 0x3c, 0xfe, 0x8a, - 0x10, 0xa3, 0xa9, 0x20, 0x28, 0xae, 0x01, 0x6a, 0xad, 0x06, 0xba, 0xf3, 0x7b, 0x81, 0xf3, 0x1b, - 0x6b, 0x29, 0x06, 0x8a, 0x4f, 0xc1, 0x64, 0xfb, 0x4a, 0xa0, 0x3b, 0xd7, 0xcf, 0xbc, 0xd6, 0xb4, - 0x77, 0x0b, 0x17, 0x02, 0xc5, 0x8d, 0x60, 0x49, 0x09, 0x57, 0x01, 0xdd, 0xd9, 0x7e, 0xf6, 0xb5, - 0x68, 0xe2, 0x0e, 0x17, 0x01, 0xc5, 0x59, 0x80, 0x60, 0x01, 0xee, 0xce, 0xeb, 0x73, 0x9c, 0x57, - 0x88, 0x88, 0x84, 0x06, 0x5f, 0x7f, 0xbb, 0xd3, 0xbf, 0x28, 0x42, 0x83, 0x53, 0x90, 0xd0, 0x10, - 0x4b, 0x6f, 0x77, 0xea, 0xcf, 0x8b, 0xd0, 0x10, 0x24, 0xc4, 0xb3, 0x43, 0xab, 0x5b, 0x77, 0x0e, - 0x5f, 0x10, 0x9e, 0x1d, 0xa2, 0x2a, 0xae, 0xc0, 0x58, 0xcb, 0x82, 0xd8, 0x9d, 0xd5, 0x17, 0x39, - 0xab, 0x6c, 0xf3, 0x7a, 0x18, 0x5e, 0xbc, 0xf8, 0x62, 0xd8, 0x9d, 0xdb, 0x97, 0x9a, 0x16, 0x2f, - 0xbe, 0x16, 0x16, 0xcf, 0x43, 0xca, 0x6c, 0x18, 0x06, 0x09, 0x1e, 0xb4, 0xff, 0x9d, 0xbf, 0xdc, - 0x1f, 0xbe, 0xce, 0xad, 0x23, 0x08, 0x8a, 0x8f, 0x42, 0x12, 0xd7, 0xb7, 0x70, 0xb5, 0x1b, 0xe5, - 0xf7, 0x5e, 0x17, 0x09, 0x93, 0x60, 0x17, 0x9f, 0x00, 0x60, 0x47, 0x23, 0xf4, 0xf1, 0x60, 0x17, - 0xda, 0xff, 0xfa, 0x3a, 0xbf, 0x8d, 0x13, 0x90, 0x04, 0x0c, 0xd8, 0xdd, 0x9e, 0xfd, 0x19, 0x7c, - 0x3f, 0xca, 0x80, 0xce, 0xc8, 0xe3, 0x30, 0xf8, 0x8c, 0x6b, 0x99, 0x9e, 0x5a, 0xeb, 0x46, 0xfd, - 0xdf, 0x38, 0xb5, 0xc0, 0x27, 0x06, 0xab, 0x5b, 0x0e, 0xf6, 0xd4, 0x9a, 0xdb, 0x8d, 0xf6, 0xbf, - 0x73, 0x5a, 0x9f, 0x80, 0x10, 0x6b, 0xaa, 0xeb, 0xf5, 0xa2, 0xf7, 0x1f, 0x09, 0x62, 0x41, 0x40, - 0x84, 0x26, 0xbf, 0xaf, 0xe2, 0xbd, 0x6e, 0xb4, 0x7f, 0x2c, 0x84, 0xe6, 0xf8, 0xc5, 0xf7, 0x40, - 0x9a, 0xfc, 0x64, 0x57, 0xec, 0xba, 0x10, 0xff, 0x0f, 0x4e, 0x1c, 0x50, 0x90, 0x91, 0x5d, 0xaf, - 0xea, 0xe9, 0xdd, 0x8d, 0x7d, 0x8b, 0xcf, 0xb4, 0xc0, 0x2f, 0xce, 0x42, 0xc6, 0xf5, 0xaa, 0xd5, - 0x06, 0xaf, 0x4f, 0xbb, 0x90, 0xff, 0xcf, 0xd7, 0xfd, 0x23, 0x0b, 0x9f, 0x86, 0xcc, 0xf6, 0xf5, - 0xab, 0x9e, 0x6d, 0xd1, 0x47, 0x20, 0xdd, 0x38, 0xbc, 0xc6, 0x39, 0x84, 0x48, 0x8a, 0x73, 0x30, - 0x44, 0x74, 0x71, 0xb0, 0x8d, 0xe9, 0xf3, 0xaa, 0x2e, 0x2c, 0xfe, 0x17, 0x37, 0x40, 0x84, 0xa8, - 0xf4, 0xa3, 0xdf, 0x78, 0x75, 0x4a, 0x7a, 0xf9, 0xd5, 0x29, 0xe9, 0x0f, 0x5e, 0x9d, 0x92, 0x3e, - 0xfd, 0xed, 0xa9, 0x43, 0x2f, 0x7f, 0x7b, 0xea, 0xd0, 0xef, 0x7d, 0x7b, 0xea, 0x50, 0xfb, 0x63, - 0x63, 0x58, 0xb0, 0x16, 0x2c, 0x76, 0x60, 0xfc, 0x01, 0x39, 0x72, 0x5c, 0x5c, 0xb3, 0x82, 0xd3, - 0x5a, 0x7f, 0x93, 0x03, 0x1f, 0x8b, 0xc3, 0x94, 0x66, 0xb9, 0x75, 0xcb, 0x9d, 0xd9, 0x52, 0x5d, - 0x3c, 0x73, 0xed, 0xe1, 0x2d, 0xec, 0xa9, 0x0f, 0xcf, 0x68, 0x96, 0x6e, 0xf2, 0x63, 0xdf, 0x71, - 0xd6, 0x5f, 0x20, 0xfd, 0x05, 0xde, 0x9f, 0x6f, 0x7b, 0x42, 0x2c, 0x2f, 0x40, 0x62, 0xce, 0xd2, - 0x4d, 0x34, 0x01, 0xc9, 0x2a, 0x36, 0xad, 0x3a, 0xbf, 0x01, 0xc6, 0x1a, 0xe8, 0x2e, 0x18, 0x50, - 0xeb, 0x56, 0xc3, 0xf4, 0xd8, 0x71, 0x79, 0x29, 0xf3, 0x8d, 0x9b, 0xd3, 0x87, 0x7e, 0xff, 0xe6, - 0x74, 0x7c, 0xd1, 0xf4, 0x14, 0xde, 0x55, 0x4c, 0x7c, 0xf7, 0xa5, 0x69, 0x49, 0xbe, 0x04, 0x83, - 0xf3, 0x58, 0x3b, 0x08, 0xaf, 0x79, 0xac, 0x35, 0xf1, 0xba, 0x0f, 0x52, 0x8b, 0xa6, 0xc7, 0xee, - 0xe8, 0x1d, 0x87, 0xb8, 0x6e, 0xb2, 0x5b, 0x1f, 0x4d, 0xe3, 0x13, 0x38, 0x41, 0x9d, 0xc7, 0x9a, - 0x8f, 0x5a, 0xc5, 0x5a, 0x33, 0x2a, 0x61, 0x4f, 0xe0, 0xa5, 0xf9, 0xdf, 0xfb, 0x4f, 0x53, 0x87, - 0x9e, 0x7b, 0x75, 0xea, 0x50, 0xa7, 0xf9, 0x89, 0x98, 0x9f, 0x9b, 0x98, 0xfd, 0x79, 0xd0, 0xad, - 0x5e, 0x9d, 0x21, 0xa1, 0xe5, 0x6e, 0x0d, 0x50, 0xbb, 0x3d, 0x02, 0x9f, 0x8e, 0xc1, 0x74, 0xf3, - 0x91, 0x3a, 0xf1, 0x63, 0xd7, 0x53, 0xeb, 0x76, 0xa7, 0x17, 0xa2, 0xce, 0x43, 0x7a, 0x43, 0xe0, - 0xa0, 0x1c, 0x0c, 0xba, 0x58, 0xb3, 0xcc, 0xaa, 0x4b, 0x45, 0x8e, 0x2b, 0xa2, 0x49, 0x0c, 0x68, - 0xaa, 0xa6, 0xe5, 0xf2, 0xfb, 0x9a, 0xac, 0x51, 0xfa, 0xcb, 0x52, 0x7f, 0x8e, 0x35, 0xe2, 0x0f, - 0x45, 0xcd, 0xb3, 0x26, 0x7d, 0xe0, 0xfe, 0xfd, 0x9e, 0x46, 0x50, 0xf5, 0x02, 0x15, 0x42, 0x8f, - 0x1e, 0xa6, 0x9a, 0x1f, 0x3d, 0x3c, 0x85, 0x0d, 0xe3, 0xb2, 0x69, 0x5d, 0x37, 0x37, 0x22, 0x26, - 0xf9, 0x5d, 0x09, 0x4e, 0xd0, 0x8b, 0xe8, 0x4e, 0x5d, 0x37, 0xbd, 0x19, 0x43, 0xdf, 0x72, 0x67, - 0xb6, 0x74, 0xcf, 0x65, 0x96, 0xe3, 0x36, 0x99, 0x08, 0x30, 0x0a, 0x04, 0xa3, 0x40, 0x30, 0xe4, - 0x33, 0x90, 0x2a, 0xe9, 0xde, 0xac, 0xe3, 0xa8, 0x7b, 0x08, 0x41, 0x82, 0xc0, 0xb8, 0x51, 0xe8, - 0x6f, 0x62, 0x11, 0x6c, 0xe0, 0xba, 0x4b, 0x1f, 0x7a, 0x25, 0x14, 0xd6, 0x28, 0x6d, 0x76, 0x9c, - 0xc9, 0xf3, 0x21, 0x4d, 0x43, 0x22, 0x85, 0x7e, 0xb2, 0x48, 0x68, 0x27, 0xae, 0xaf, 0xcf, 0x57, - 0x12, 0x70, 0x3c, 0x84, 0xa0, 0x39, 0x7b, 0xb6, 0x47, 0x43, 0xd2, 0xda, 0xe6, 0xca, 0x8c, 0x85, - 0x94, 0x61, 0xdd, 0x1d, 0xc2, 0x6c, 0x1b, 0x92, 0x6b, 0x84, 0x8e, 0x28, 0xe2, 0x59, 0x9e, 0x6a, - 0x70, 0xed, 0x58, 0x83, 0x40, 0xd9, 0x65, 0xfc, 0x18, 0x83, 0xea, 0xe2, 0x1e, 0xbe, 0x81, 0xd5, - 0x6d, 0x76, 0xf9, 0x31, 0x4e, 0x9f, 0x7d, 0xa6, 0x08, 0x80, 0xde, 0x73, 0x9c, 0x80, 0xa4, 0xda, - 0x60, 0x8f, 0xed, 0xe2, 0x27, 0x87, 0x14, 0xd6, 0x90, 0x2f, 0xc3, 0x20, 0x7f, 0x54, 0x80, 0xb2, - 0x10, 0xbf, 0x8a, 0xf7, 0xe8, 0x38, 0x43, 0x0a, 0xf9, 0x89, 0x0a, 0x90, 0xa4, 0xc2, 0xf3, 0x5b, - 0xdd, 0xb9, 0x42, 0x8b, 0xf4, 0x05, 0x2a, 0xa4, 0xc2, 0xd0, 0xe4, 0x4b, 0x90, 0x9a, 0xb7, 0xea, - 0xba, 0x69, 0x45, 0xb9, 0xa5, 0x19, 0x37, 0x2a, 0xb3, 0xdd, 0xe0, 0xe1, 0xac, 0xb0, 0x06, 0x9a, - 0x84, 0x01, 0x76, 0x19, 0x96, 0x3f, 0x7a, 0xe4, 0x2d, 0x79, 0x0e, 0x06, 0x29, 0xef, 0x55, 0x9b, - 0xcc, 0xaf, 0x7f, 0x11, 0x29, 0xcd, 0xdf, 0x78, 0xe0, 0xec, 0x63, 0x81, 0xb0, 0x08, 0x12, 0x55, - 0xd5, 0x53, 0xb9, 0xde, 0xf4, 0xb7, 0xfc, 0x5e, 0x48, 0x71, 0x26, 0x2e, 0x3a, 0x0d, 0x71, 0xcb, - 0x76, 0xf9, 0xc3, 0xc3, 0x7c, 0x27, 0x55, 0x56, 0xed, 0x52, 0x82, 0x24, 0x02, 0x85, 0x20, 0x97, - 0x94, 0x8e, 0xfe, 0x72, 0xae, 0x7f, 0x7f, 0x61, 0xc3, 0xf8, 0xce, 0xf2, 0x85, 0x18, 0x4c, 0x85, - 0x7a, 0xaf, 0x61, 0x87, 0xd4, 0xcb, 0x11, 0xd7, 0x47, 0x21, 0x21, 0x79, 0x7f, 0x07, 0x77, 0x79, - 0x0f, 0xc4, 0x67, 0x6d, 0x1b, 0xe5, 0x21, 0xc5, 0x1e, 0x12, 0x5a, 0xcc, 0x5f, 0x12, 0x8a, 0xdf, - 0x26, 0x7d, 0xae, 0xb5, 0xed, 0x5d, 0x57, 0x1d, 0xff, 0x35, 0x10, 0xd1, 0x96, 0x1f, 0x87, 0xf4, - 0x9c, 0x65, 0xba, 0xd8, 0x74, 0x1b, 0x34, 0x74, 0xb6, 0x0c, 0x4b, 0xbb, 0xca, 0x39, 0xb0, 0x06, - 0x31, 0xb8, 0x6a, 0xdb, 0x94, 0x32, 0xa1, 0x90, 0x9f, 0x2c, 0xf5, 0x96, 0xd6, 0x3b, 0x9a, 0xe8, - 0xf1, 0xfe, 0x4d, 0xc4, 0x95, 0xf4, 0x6d, 0xf4, 0xeb, 0x47, 0xe0, 0x58, 0x98, 0x94, 0x65, 0x9c, - 0x90, 0x85, 0xb2, 0x21, 0x0b, 0x51, 0x78, 0x7b, 0xfb, 0xe4, 0xbb, 0x65, 0xde, 0x7c, 0xd7, 0x3c, - 0x94, 0xdf, 0x3f, 0xb2, 0xf3, 0x5d, 0xe6, 0x52, 0x7e, 0x1c, 0x86, 0xd7, 0x54, 0xc7, 0x5b, 0xc7, - 0xde, 0x45, 0xac, 0x56, 0xb1, 0x13, 0x0d, 0xec, 0x61, 0x11, 0xd8, 0x08, 0x12, 0x34, 0x7a, 0x99, - 0x63, 0xd3, 0xdf, 0xf2, 0x0e, 0x24, 0xe8, 0x45, 0x03, 0x3f, 0xe8, 0x39, 0x05, 0x0b, 0x7a, 0x32, - 0x5d, 0x7b, 0x1e, 0x76, 0x39, 0x09, 0x6b, 0xa0, 0x33, 0x22, 0x74, 0xe3, 0xfb, 0x87, 0x2e, 0xf7, - 0x76, 0x1e, 0xc0, 0x06, 0x0c, 0x96, 0xc8, 0x6c, 0x2f, 0xce, 0xfb, 0x82, 0x48, 0x81, 0x20, 0x68, - 0x19, 0x46, 0x6d, 0xd5, 0xf1, 0xe8, 0x0d, 0xcb, 0x1d, 0xaa, 0x05, 0xcf, 0x0c, 0xd3, 0x85, 0xe6, - 0x79, 0x28, 0x44, 0x94, 0xe5, 0xa3, 0x0c, 0xdb, 0x61, 0xa0, 0xfc, 0x9f, 0x13, 0x30, 0xc0, 0x8d, - 0xf1, 0x1e, 0x18, 0xe4, 0x46, 0xa3, 0x03, 0x66, 0x4e, 0x1f, 0x2f, 0xb4, 0xfa, 0x7e, 0xc1, 0xf7, - 0x51, 0xce, 0x4f, 0xd0, 0xa0, 0x7b, 0x20, 0xa5, 0xed, 0xa8, 0xba, 0x59, 0xd1, 0xab, 0xa2, 0x58, - 0x78, 0xf5, 0xe6, 0xf4, 0xe0, 0x1c, 0x81, 0x2d, 0xce, 0x2b, 0x83, 0xb4, 0x73, 0xb1, 0x4a, 0x92, - 0xcd, 0x0e, 0xd6, 0x6b, 0x3b, 0x2c, 0xd9, 0xc4, 0x15, 0xde, 0x42, 0xe7, 0x20, 0x41, 0x1c, 0x82, - 0x5f, 0xc0, 0xcf, 0xb7, 0x14, 0x71, 0xfe, 0xc2, 0x58, 0x4a, 0x91, 0x81, 0x3f, 0xfd, 0xad, 0x69, - 0x49, 0xa1, 0x14, 0x68, 0x0e, 0x86, 0x0d, 0xd5, 0xf5, 0x2a, 0x34, 0x48, 0xc8, 0xf0, 0x49, 0xca, - 0xe2, 0x48, 0xab, 0x41, 0xb8, 0x61, 0xb9, 0xe8, 0x19, 0x42, 0xc5, 0x40, 0x55, 0x74, 0x12, 0xb2, - 0x94, 0x89, 0x66, 0xd5, 0xeb, 0xba, 0xc7, 0xd2, 0xf7, 0x00, 0xb5, 0xfb, 0x08, 0x81, 0xcf, 0x51, - 0x30, 0x4d, 0xe2, 0x47, 0x21, 0x4d, 0x6f, 0xfc, 0x52, 0x14, 0x76, 0xbb, 0x25, 0x45, 0x00, 0xb4, - 0xf3, 0x5e, 0x18, 0xbd, 0xa6, 0x1a, 0x7a, 0x55, 0xf5, 0x2c, 0xc7, 0x65, 0x28, 0x29, 0xc6, 0x25, - 0x00, 0x53, 0xc4, 0x87, 0x60, 0xc2, 0xc4, 0xbb, 0xf4, 0xbe, 0x4d, 0x04, 0x3b, 0x4d, 0xb1, 0x11, - 0xe9, 0xbb, 0x12, 0xa5, 0x78, 0x17, 0x8c, 0x68, 0xc2, 0xf8, 0x0c, 0x17, 0x28, 0xee, 0xb0, 0x0f, - 0xa5, 0x68, 0x47, 0x20, 0xa5, 0xda, 0x36, 0x43, 0xc8, 0x50, 0x84, 0x41, 0xd5, 0xb6, 0x69, 0xd7, - 0x29, 0x18, 0xa3, 0x3a, 0x3a, 0xd8, 0x6d, 0x18, 0x1e, 0x67, 0x32, 0x44, 0x71, 0x46, 0x49, 0x87, - 0xc2, 0xe0, 0x14, 0xf7, 0x2e, 0x18, 0xc6, 0xd7, 0xf4, 0x2a, 0x36, 0x35, 0xcc, 0xf0, 0x86, 0x29, - 0xde, 0x90, 0x00, 0x52, 0xa4, 0xfb, 0x20, 0x6b, 0x3b, 0x96, 0x6d, 0xb9, 0xd8, 0xa9, 0xa8, 0xd5, - 0xaa, 0x83, 0x5d, 0x37, 0x37, 0xc2, 0xf8, 0x09, 0xf8, 0x2c, 0x03, 0xcb, 0x0f, 0x40, 0x62, 0x5e, - 0xf5, 0x54, 0x92, 0xc3, 0xbc, 0x5d, 0xb6, 0x04, 0x0c, 0x29, 0xe4, 0x67, 0xdb, 0x70, 0xfb, 0x6e, - 0x0c, 0x12, 0x57, 0x2c, 0x0f, 0xa3, 0x47, 0x42, 0xeb, 0xce, 0x48, 0x3b, 0x1f, 0x5f, 0xd7, 0x6b, - 0x26, 0xae, 0x2e, 0xbb, 0xb5, 0xd0, 0xab, 0x78, 0x81, 0x8b, 0xc5, 0x22, 0x2e, 0x36, 0x01, 0x49, - 0xc7, 0x6a, 0x98, 0x55, 0x71, 0x59, 0x84, 0x36, 0x50, 0x19, 0x52, 0xbe, 0xe7, 0x24, 0xba, 0x79, - 0xce, 0x28, 0xf1, 0x1c, 0xe2, 0xd7, 0x1c, 0xa0, 0x0c, 0x6e, 0x71, 0x07, 0x2a, 0x41, 0xda, 0x4f, - 0x68, 0xdc, 0x03, 0x7b, 0x73, 0xe2, 0x80, 0x0c, 0xdd, 0x0f, 0x63, 0xbe, 0x3f, 0xf8, 0x06, 0x65, - 0x5e, 0x98, 0xf5, 0x3b, 0xb8, 0x45, 0x23, 0xae, 0xc6, 0x5f, 0x0b, 0x1c, 0xa4, 0x7a, 0x05, 0xae, - 0xc6, 0x5e, 0x0d, 0x3c, 0x06, 0x69, 0x57, 0xaf, 0x99, 0xaa, 0xd7, 0x70, 0x30, 0xf7, 0xc6, 0x00, - 0x20, 0xff, 0x54, 0x0c, 0x06, 0x98, 0x77, 0x87, 0xec, 0x26, 0xb5, 0xb7, 0x5b, 0xac, 0x93, 0xdd, - 0xe2, 0x07, 0xb7, 0xdb, 0x2c, 0x80, 0x2f, 0x8c, 0xcb, 0x5f, 0xeb, 0x3a, 0xda, 0xca, 0x88, 0x89, - 0xb8, 0xae, 0xd7, 0x78, 0xf0, 0x86, 0x88, 0x7c, 0x0f, 0x4a, 0x86, 0xf2, 0xe4, 0x79, 0x48, 0x6f, - 0xe9, 0x5e, 0x45, 0x25, 0xd5, 0x29, 0x35, 0x61, 0xe6, 0xf4, 0x54, 0xa1, 0x5d, 0x19, 0x5b, 0x10, - 0x35, 0xac, 0x92, 0xda, 0xe2, 0xbf, 0xe4, 0xff, 0x28, 0x91, 0xc5, 0x98, 0x0f, 0x88, 0x66, 0x61, - 0x58, 0x28, 0x5a, 0xd9, 0x36, 0xd4, 0x1a, 0x77, 0xc6, 0xe3, 0x1d, 0xb5, 0xbd, 0x60, 0xa8, 0x35, - 0x25, 0xc3, 0x15, 0x24, 0x8d, 0xf6, 0x13, 0x1b, 0xeb, 0x30, 0xb1, 0x11, 0x4f, 0x8a, 0x1f, 0xcc, - 0x93, 0x22, 0x73, 0x9e, 0x68, 0x9e, 0xf3, 0xaf, 0xc6, 0x68, 0x51, 0x66, 0x5b, 0xae, 0x6a, 0xbc, - 0x15, 0x21, 0x76, 0x14, 0xd2, 0xb6, 0x65, 0x54, 0x58, 0x0f, 0xbb, 0x95, 0x95, 0xb2, 0x2d, 0x43, - 0x69, 0xf1, 0xa3, 0xe4, 0x6d, 0x8a, 0xbf, 0x81, 0xdb, 0x60, 0xb5, 0xc1, 0x66, 0xab, 0x39, 0x30, - 0xc4, 0x4c, 0xc1, 0x17, 0xcc, 0x87, 0x88, 0x0d, 0xe8, 0x0a, 0x2c, 0xb5, 0x2e, 0xf0, 0x4c, 0x6c, - 0x86, 0xa9, 0x70, 0x3c, 0x42, 0xc1, 0xd6, 0x97, 0x76, 0xd5, 0x7c, 0xd8, 0xcf, 0x15, 0x8e, 0x27, - 0xff, 0x53, 0x09, 0xd2, 0x54, 0xd5, 0x65, 0xec, 0xa9, 0x11, 0x53, 0x49, 0x07, 0x37, 0xd5, 0x71, - 0x00, 0xc6, 0xc6, 0xd5, 0x6f, 0x60, 0x3e, 0x81, 0x69, 0x0a, 0x59, 0xd7, 0x6f, 0x60, 0x74, 0xd6, - 0xd7, 0x2b, 0xbe, 0xbf, 0x5e, 0x3c, 0x14, 0x85, 0x76, 0x77, 0xc0, 0x20, 0xfd, 0x2a, 0xc1, 0x2e, - 0xbb, 0x96, 0x18, 0xa7, 0xef, 0x2c, 0x6e, 0xec, 0xba, 0xf2, 0x33, 0x30, 0xb8, 0xb1, 0xcb, 0xb6, - 0x52, 0x47, 0x21, 0xed, 0x58, 0x16, 0x5f, 0x5f, 0x59, 0x5d, 0x93, 0x22, 0x00, 0xba, 0x9c, 0x88, - 0xed, 0x43, 0x2c, 0xd8, 0x3e, 0x04, 0xfb, 0x9f, 0x78, 0x4f, 0xfb, 0x9f, 0x53, 0xff, 0x4e, 0x82, - 0x4c, 0x28, 0x0c, 0xd1, 0xc3, 0x70, 0xb8, 0xb4, 0xb4, 0x3a, 0x77, 0xb9, 0xb2, 0x38, 0x5f, 0xb9, - 0xb0, 0x34, 0xbb, 0x10, 0x5c, 0xef, 0xcd, 0x4f, 0x3e, 0xff, 0xe2, 0x09, 0x14, 0xc2, 0xdd, 0x34, - 0xaf, 0x92, 0xfd, 0x31, 0x9a, 0x81, 0x89, 0x28, 0xc9, 0x6c, 0x69, 0xbd, 0xbc, 0xb2, 0x91, 0x95, - 0xf2, 0x87, 0x9f, 0x7f, 0xf1, 0xc4, 0x58, 0x88, 0x62, 0x76, 0xcb, 0xc5, 0xa6, 0xd7, 0x4a, 0x30, - 0xb7, 0xba, 0xbc, 0xbc, 0xb8, 0x91, 0x8d, 0xb5, 0x10, 0xf0, 0x44, 0x7b, 0x1f, 0x8c, 0x45, 0x09, - 0x56, 0x16, 0x97, 0xb2, 0xf1, 0x3c, 0x7a, 0xfe, 0xc5, 0x13, 0x23, 0x21, 0xec, 0x15, 0xdd, 0xc8, - 0xa7, 0x7e, 0xe2, 0x4b, 0x53, 0x87, 0x7e, 0xfe, 0xaf, 0x4d, 0x49, 0x44, 0xb3, 0xe1, 0x48, 0x28, - 0xa2, 0x07, 0xe0, 0x8e, 0xf5, 0xc5, 0x85, 0x95, 0xf2, 0x7c, 0x65, 0x79, 0x7d, 0xa1, 0xc2, 0xde, - 0x6b, 0xf6, 0xb5, 0x1b, 0x7d, 0xfe, 0xc5, 0x13, 0x19, 0xae, 0x52, 0x27, 0xec, 0x35, 0xa5, 0x7c, - 0x65, 0x75, 0xa3, 0x9c, 0x95, 0x18, 0xf6, 0x9a, 0x83, 0xaf, 0x59, 0x1e, 0xfb, 0x6c, 0xc9, 0x43, - 0x70, 0xa4, 0x0d, 0xb6, 0xaf, 0xd8, 0xd8, 0xf3, 0x2f, 0x9e, 0x18, 0x5e, 0x73, 0x30, 0x73, 0x53, - 0x4a, 0x51, 0x80, 0x5c, 0x2b, 0xc5, 0xea, 0xda, 0xea, 0xfa, 0xec, 0x52, 0xf6, 0x44, 0x3e, 0xfb, - 0xfc, 0x8b, 0x27, 0x86, 0x44, 0xce, 0x21, 0xf8, 0x81, 0x66, 0xa5, 0x27, 0x3b, 0xee, 0x5f, 0x1e, - 0xeb, 0x7f, 0xff, 0x12, 0x3d, 0xf1, 0xf9, 0x8b, 0x31, 0x98, 0x6a, 0xb9, 0x44, 0xc9, 0x8f, 0x1e, - 0x3b, 0x1d, 0xf8, 0x14, 0x21, 0x35, 0x2f, 0x4e, 0x34, 0xfb, 0x3d, 0xef, 0xf9, 0xd9, 0x3e, 0xcf, - 0x7b, 0x86, 0xc5, 0x48, 0xe2, 0xb8, 0xe7, 0x54, 0xf7, 0xe3, 0x1e, 0x21, 0xff, 0x01, 0x4e, 0x7b, - 0x3e, 0xfe, 0x30, 0xdc, 0xcd, 0x0f, 0xc9, 0x5c, 0x4f, 0xbd, 0xaa, 0x9b, 0x35, 0xff, 0x28, 0x92, - 0xb7, 0xb9, 0x51, 0x26, 0xf9, 0x69, 0xa4, 0x80, 0xee, 0x7b, 0x20, 0x99, 0xdf, 0x77, 0x83, 0xd8, - 0x7d, 0xe3, 0xd7, 0x65, 0x86, 0xf2, 0x5d, 0x8e, 0x4e, 0xe5, 0x4f, 0x4a, 0x30, 0x72, 0x51, 0x77, - 0x3d, 0xcb, 0xd1, 0x35, 0xd5, 0xa0, 0xb7, 0x95, 0xcf, 0xf6, 0x9a, 0x9b, 0x9b, 0x72, 0xd8, 0x13, - 0x30, 0x70, 0x4d, 0x35, 0x5c, 0xec, 0xf1, 0xcb, 0xfa, 0x77, 0x16, 0xda, 0x1b, 0xa2, 0xe0, 0x17, - 0xe7, 0x82, 0x01, 0x23, 0x93, 0x7f, 0x31, 0x06, 0xa3, 0x34, 0xca, 0x5d, 0xf6, 0x39, 0x0d, 0xb2, - 0x11, 0x2c, 0x41, 0xc2, 0x51, 0x3d, 0x7e, 0x78, 0x52, 0x2a, 0xf0, 0x43, 0xce, 0x7b, 0xba, 0x1f, - 0x5c, 0x16, 0xe6, 0xb1, 0xa6, 0x50, 0x5a, 0xf4, 0x23, 0x90, 0xaa, 0xab, 0xbb, 0x15, 0xca, 0x87, - 0x6d, 0xaf, 0x66, 0xfb, 0xe3, 0x73, 0xeb, 0xe6, 0xf4, 0xe8, 0x9e, 0x5a, 0x37, 0x8a, 0xb2, 0xe0, - 0x23, 0x2b, 0x83, 0x75, 0x75, 0x97, 0x88, 0x88, 0x6c, 0x18, 0x25, 0x50, 0x6d, 0x47, 0x35, 0x6b, - 0x98, 0x0d, 0x42, 0x8f, 0x82, 0x4a, 0x17, 0xfb, 0x1e, 0x64, 0x32, 0x18, 0x24, 0xc4, 0x4e, 0x56, - 0x86, 0xeb, 0xea, 0xee, 0x1c, 0x05, 0x90, 0x11, 0x8b, 0xa9, 0x17, 0x5e, 0x9a, 0x3e, 0x44, 0x0f, - 0x8e, 0x5f, 0x91, 0x00, 0x02, 0x8b, 0xa1, 0x1f, 0x81, 0xac, 0xe6, 0xb7, 0x28, 0xad, 0xcb, 0xe7, - 0xf0, 0xde, 0x4e, 0x73, 0xd1, 0x64, 0x6f, 0xb6, 0xb6, 0xbf, 0x7c, 0x73, 0x5a, 0x52, 0x46, 0xb5, - 0xa6, 0xa9, 0xf8, 0x20, 0x64, 0x1a, 0x76, 0x55, 0xf5, 0x70, 0x85, 0x6e, 0x36, 0x63, 0x5d, 0xeb, - 0x84, 0x29, 0xc2, 0xeb, 0xd6, 0xcd, 0x69, 0xc4, 0xd4, 0x0a, 0x11, 0xcb, 0xb4, 0x7a, 0x00, 0x06, - 0x21, 0x04, 0x21, 0x9d, 0x7e, 0x47, 0x82, 0xcc, 0x7c, 0xe8, 0xd6, 0x40, 0x0e, 0x06, 0xeb, 0x96, - 0xa9, 0x5f, 0xe5, 0xfe, 0x98, 0x56, 0x44, 0x13, 0xe5, 0x21, 0xc5, 0x5e, 0xe0, 0xf0, 0xf6, 0xc4, - 0x91, 0x90, 0x68, 0x13, 0xaa, 0xeb, 0x78, 0xcb, 0xd5, 0xc5, 0x6c, 0x28, 0xa2, 0x89, 0x2e, 0x40, - 0xd6, 0xc5, 0x5a, 0xc3, 0xd1, 0xbd, 0xbd, 0x8a, 0x66, 0x99, 0x9e, 0xaa, 0x79, 0xec, 0x55, 0x80, - 0xd2, 0xd1, 0x5b, 0x37, 0xa7, 0xef, 0x60, 0xb2, 0x36, 0x63, 0xc8, 0xca, 0xa8, 0x00, 0xcd, 0x31, - 0x08, 0x19, 0xa1, 0x8a, 0x3d, 0x55, 0x37, 0x5c, 0x5a, 0x7a, 0xa5, 0x15, 0xd1, 0x0c, 0xe9, 0xf2, - 0x8f, 0x07, 0x21, 0xed, 0x7b, 0x3b, 0xba, 0x0e, 0x59, 0xcb, 0xc6, 0x4e, 0xa4, 0x90, 0xa5, 0xeb, - 0x78, 0x69, 0x29, 0x18, 0xb9, 0x19, 0x43, 0xfe, 0xff, 0x37, 0xa7, 0x1f, 0xec, 0xc1, 0x83, 0xae, - 0xa8, 0x06, 0x2f, 0x82, 0x95, 0x51, 0xc1, 0x43, 0x54, 0xc5, 0x17, 0x88, 0x5f, 0x88, 0xed, 0xaf, - 0xdd, 0xd8, 0x12, 0x47, 0x8f, 0x11, 0x95, 0x9b, 0x31, 0x64, 0xe2, 0x01, 0x1c, 0xb4, 0x46, 0x21, - 0xa4, 0x72, 0x7d, 0x46, 0xd5, 0x0d, 0xf1, 0x56, 0x9b, 0xc2, 0x5b, 0x68, 0x11, 0x06, 0x5c, 0x4f, - 0xf5, 0x1a, 0xac, 0x78, 0x49, 0x96, 0x1e, 0xee, 0x51, 0xe6, 0x92, 0x65, 0x56, 0xd7, 0x29, 0xa1, - 0xc2, 0x19, 0xa0, 0x0b, 0x30, 0xe0, 0x59, 0x57, 0xb1, 0xc9, 0x8d, 0xda, 0x57, 0xc4, 0xd3, 0x87, - 0x34, 0x8c, 0x1a, 0x79, 0x90, 0xad, 0x62, 0x03, 0xd7, 0xa8, 0x29, 0xdd, 0x1d, 0x95, 0x6c, 0x90, - 0xe8, 0x97, 0x65, 0x4a, 0x8b, 0x7d, 0x87, 0x25, 0x37, 0x50, 0x33, 0x3f, 0x59, 0x19, 0xf5, 0x41, - 0xeb, 0x14, 0x82, 0x2e, 0x47, 0x2e, 0xbc, 0xf0, 0xcf, 0x2f, 0xdd, 0xd5, 0x29, 0xf6, 0x42, 0x5e, - 0x2e, 0x8e, 0x55, 0xc2, 0xd7, 0x65, 0x2e, 0x40, 0xb6, 0x61, 0x6e, 0x59, 0x26, 0x7d, 0x13, 0x85, - 0xef, 0x18, 0xc8, 0x16, 0x34, 0x1e, 0x9e, 0xb5, 0x66, 0x0c, 0x59, 0x19, 0xf5, 0x41, 0x17, 0xd9, - 0xbe, 0xa2, 0x0a, 0x23, 0x01, 0x16, 0x0d, 0xdd, 0x74, 0xd7, 0xd0, 0xbd, 0x93, 0x87, 0xee, 0xe1, - 0xe6, 0x51, 0x82, 0xe8, 0x1d, 0xf6, 0x81, 0x84, 0x0c, 0x5d, 0x04, 0x08, 0x12, 0x06, 0x3d, 0x5e, - 0xc9, 0x9c, 0x96, 0xbb, 0x67, 0x1d, 0xb1, 0x25, 0x0d, 0x68, 0xd1, 0x87, 0x61, 0xbc, 0xae, 0x9b, - 0x15, 0x17, 0x1b, 0xdb, 0x15, 0x6e, 0x60, 0xc2, 0x92, 0x7e, 0x49, 0xa0, 0xb4, 0xd4, 0x9f, 0x3f, - 0xdc, 0xba, 0x39, 0x9d, 0xe7, 0x49, 0xb5, 0x95, 0xa5, 0xac, 0x8c, 0xd5, 0x75, 0x73, 0x1d, 0x1b, - 0xdb, 0xf3, 0x3e, 0xac, 0x38, 0xf4, 0x13, 0x2f, 0x4d, 0x1f, 0xf2, 0x03, 0x58, 0x87, 0xa1, 0x20, - 0xb0, 0xb0, 0x8b, 0x56, 0x21, 0xad, 0x8a, 0x06, 0x3b, 0x88, 0xe9, 0xd9, 0xd9, 0x43, 0x01, 0x1a, - 0xf0, 0x60, 0xb9, 0xe2, 0xb9, 0xff, 0x70, 0x42, 0x92, 0x9f, 0x8f, 0xc1, 0xc0, 0xfc, 0x95, 0x35, - 0x55, 0x77, 0xd0, 0x0d, 0x18, 0x0b, 0x9c, 0x2d, 0x9a, 0x29, 0x96, 0x6f, 0xdd, 0x9c, 0xce, 0x35, - 0xfb, 0x63, 0x9f, 0xa9, 0x62, 0x56, 0xd3, 0x84, 0x24, 0x41, 0x90, 0x88, 0x5c, 0x71, 0xa3, 0xe3, - 0x76, 0x3b, 0x3c, 0x76, 0x0b, 0xca, 0x01, 0xd2, 0x54, 0xcb, 0xee, 0x3d, 0x94, 0x38, 0xcb, 0x30, - 0xc8, 0x6c, 0xe1, 0xa2, 0x22, 0x24, 0x6d, 0xf2, 0x83, 0x3f, 0xfa, 0x98, 0xea, 0x18, 0x4d, 0x14, - 0xdf, 0x3f, 0x10, 0x26, 0x24, 0xf2, 0x17, 0xe3, 0x00, 0xf3, 0x57, 0xae, 0x6c, 0x38, 0xba, 0x6d, - 0x60, 0xef, 0x07, 0x6a, 0xd7, 0x8f, 0x4b, 0x70, 0x38, 0xb0, 0x9a, 0xeb, 0x68, 0x4d, 0xc6, 0x7d, - 0xf2, 0xd6, 0xcd, 0xe9, 0x63, 0xcd, 0xc6, 0x0d, 0xa1, 0x1d, 0xc0, 0xc0, 0xe3, 0x3e, 0xa3, 0x75, - 0x47, 0x6b, 0x2f, 0x47, 0xd5, 0xf5, 0x7c, 0x39, 0xe2, 0x9d, 0xe5, 0x08, 0xa1, 0xbd, 0x21, 0x39, - 0xe6, 0x5d, 0xaf, 0x75, 0xae, 0xd7, 0x21, 0x13, 0xcc, 0x91, 0x8b, 0xe6, 0x21, 0xe5, 0xf1, 0xdf, - 0x7c, 0xca, 0xe5, 0xce, 0x53, 0x2e, 0xc8, 0xf8, 0xb4, 0xfb, 0x94, 0xf2, 0xbf, 0x8d, 0x01, 0x04, - 0x51, 0xfd, 0x67, 0x35, 0xa2, 0xc8, 0x72, 0xca, 0x17, 0xbf, 0xf8, 0x81, 0x0a, 0x68, 0x4e, 0x1d, - 0x9a, 0xad, 0x3f, 0x8c, 0xc1, 0xf8, 0xa6, 0xc8, 0xfc, 0xef, 0x58, 0x18, 0xad, 0xc1, 0x20, 0x36, - 0x3d, 0x47, 0xa7, 0x26, 0x26, 0xde, 0xfa, 0x50, 0x27, 0x6f, 0x6d, 0x63, 0x35, 0xfa, 0xb1, 0x0c, - 0xf1, 0x34, 0x88, 0xb3, 0x09, 0xd9, 0xfa, 0x53, 0x71, 0xc8, 0x75, 0xa2, 0x42, 0x73, 0x30, 0xaa, - 0x39, 0x98, 0x02, 0x2a, 0xe1, 0xa3, 0xe7, 0x52, 0x3e, 0xd8, 0x49, 0x34, 0x21, 0xc8, 0xca, 0x88, - 0x80, 0xf0, 0xda, 0xa0, 0x06, 0xa4, 0xcc, 0x27, 0x21, 0x43, 0xb0, 0x7a, 0xac, 0xeb, 0x65, 0x5e, - 0x1c, 0x88, 0x41, 0xa2, 0x0c, 0x58, 0x75, 0x30, 0x12, 0x40, 0x69, 0x79, 0xf0, 0x2c, 0x8c, 0xea, - 0xa6, 0xee, 0xe9, 0xaa, 0x51, 0xd9, 0x52, 0x0d, 0xd5, 0xd4, 0x0e, 0xb2, 0x4b, 0x62, 0x0b, 0x3a, - 0x1f, 0xb6, 0x89, 0x9d, 0xac, 0x8c, 0x70, 0x48, 0x89, 0x01, 0xd0, 0x45, 0x18, 0x14, 0x43, 0x25, - 0x0e, 0x54, 0x4b, 0x0a, 0xf2, 0xd0, 0x8c, 0xfc, 0x64, 0x1c, 0xc6, 0x14, 0x5c, 0x7d, 0x67, 0x2a, - 0xfa, 0x9b, 0x8a, 0x65, 0x00, 0x96, 0x48, 0xc8, 0x4a, 0x72, 0x80, 0xd9, 0x20, 0xa9, 0x28, 0xcd, - 0x38, 0xcc, 0xbb, 0x5e, 0x68, 0x3e, 0xfe, 0x28, 0x0e, 0x43, 0xe1, 0xf9, 0x78, 0x67, 0x89, 0xff, - 0xe1, 0x59, 0xe2, 0xd1, 0x62, 0x90, 0x1a, 0x13, 0xfc, 0xa3, 0x87, 0x1d, 0x52, 0x63, 0x4b, 0x48, - 0x75, 0xce, 0x89, 0xff, 0x3b, 0x06, 0x03, 0x6b, 0xaa, 0xa3, 0xd6, 0x5d, 0xa4, 0xb5, 0x6c, 0x6c, - 0xc4, 0xc1, 0x7e, 0xcb, 0xd7, 0x6a, 0xf9, 0xa1, 0x58, 0x97, 0x7d, 0xcd, 0x0b, 0x6d, 0xf6, 0x35, - 0xef, 0x83, 0x91, 0xba, 0xba, 0x1b, 0x7a, 0xd6, 0x4c, 0x27, 0x73, 0xb8, 0x74, 0x24, 0xe0, 0x12, - 0xed, 0x67, 0xc7, 0x35, 0xc1, 0x03, 0x68, 0xf4, 0x18, 0x64, 0x08, 0x46, 0xb0, 0x4a, 0x10, 0xf2, - 0xc9, 0xe0, 0x5c, 0x24, 0xd4, 0x29, 0x2b, 0x50, 0x57, 0x77, 0xcb, 0xac, 0x81, 0x96, 0x00, 0xed, - 0xf8, 0x47, 0x73, 0x95, 0xc0, 0x94, 0x84, 0xfe, 0xf8, 0xad, 0x9b, 0xd3, 0x47, 0x18, 0x7d, 0x2b, - 0x8e, 0xac, 0x8c, 0x05, 0x40, 0xc1, 0xed, 0x0c, 0x00, 0xd1, 0xab, 0xc2, 0xae, 0x2a, 0xb2, 0xdd, - 0xf5, 0xe1, 0x5b, 0x37, 0xa7, 0xc7, 0x18, 0x97, 0xa0, 0x4f, 0x56, 0xd2, 0xa4, 0x31, 0x4f, 0x7e, - 0x87, 0x0c, 0xff, 0x25, 0x09, 0x50, 0xb0, 0x06, 0x29, 0xd8, 0xb5, 0x2d, 0xd3, 0xa5, 0xfb, 0xbe, - 0xd0, 0x26, 0x4d, 0xda, 0x7f, 0xdf, 0x17, 0xd0, 0x8b, 0x7d, 0x5f, 0x28, 0x74, 0x1f, 0x0f, 0xf2, - 0x75, 0x8c, 0xcf, 0x63, 0x9b, 0x7b, 0x9d, 0x85, 0x39, 0x4b, 0x17, 0xd4, 0x6d, 0x12, 0xf4, 0xbf, - 0x90, 0xe0, 0x48, 0x8b, 0x37, 0xf9, 0xc2, 0xfe, 0x39, 0x40, 0x4e, 0xa8, 0x93, 0x7f, 0xbc, 0x8a, - 0x09, 0xdd, 0xb7, 0x73, 0x8e, 0x39, 0x2d, 0x0b, 0xc1, 0xed, 0x5b, 0x72, 0xd8, 0xc5, 0xd0, 0x7f, - 0x22, 0xc1, 0x44, 0x78, 0x78, 0x5f, 0x91, 0x15, 0x18, 0x0a, 0x8f, 0xce, 0x55, 0xb8, 0xbb, 0x17, - 0x15, 0xb8, 0xf4, 0x11, 0x7a, 0xf4, 0x64, 0x10, 0xaa, 0xec, 0xf0, 0xf6, 0xe1, 0x9e, 0xad, 0x21, - 0x64, 0x6a, 0x0e, 0x59, 0xa6, 0xc1, 0x9f, 0x48, 0x90, 0x58, 0xb3, 0x2c, 0x03, 0x59, 0x30, 0x66, - 0x5a, 0x5e, 0x85, 0x78, 0x16, 0xae, 0x56, 0xf8, 0x19, 0x0f, 0x3b, 0xd5, 0x9d, 0xeb, 0xcf, 0x48, - 0xdf, 0xbb, 0x39, 0xdd, 0xca, 0x4a, 0x19, 0x35, 0x2d, 0xaf, 0x44, 0x21, 0x1b, 0xec, 0x04, 0xe8, - 0xc3, 0x30, 0x1c, 0x1d, 0x8c, 0x9d, 0x78, 0x3d, 0xd5, 0xf7, 0x60, 0x51, 0x36, 0xb7, 0x6e, 0x4e, - 0x4f, 0x04, 0x11, 0xe3, 0x83, 0x65, 0x65, 0x68, 0x2b, 0x34, 0x7a, 0x31, 0x45, 0xb4, 0xff, 0xe3, - 0x97, 0xa6, 0xa5, 0xd2, 0x85, 0x8e, 0x4f, 0x68, 0x1e, 0xd8, 0x57, 0x84, 0x5d, 0xff, 0x31, 0x43, - 0xf4, 0xb1, 0xcc, 0x0b, 0xe3, 0x30, 0xdd, 0xe1, 0x39, 0x84, 0xb7, 0x7b, 0xa0, 0x47, 0x10, 0x5d, - 0x9e, 0x11, 0xe4, 0x7b, 0x7a, 0xec, 0x21, 0xbf, 0x9e, 0x00, 0xb4, 0xec, 0xd6, 0xe6, 0x48, 0x55, - 0x83, 0x83, 0x43, 0xcf, 0xa6, 0x23, 0x31, 0xe9, 0x0d, 0x1d, 0x89, 0x2d, 0x47, 0x0e, 0x99, 0x62, - 0xfd, 0x1d, 0x6d, 0xf7, 0x7c, 0xd2, 0x14, 0x7f, 0x4b, 0x4e, 0x9a, 0xda, 0x97, 0x2a, 0x89, 0x1f, - 0xe0, 0x8e, 0x29, 0xf9, 0xd6, 0xec, 0x98, 0x26, 0x61, 0x80, 0x9f, 0x41, 0xb3, 0x4f, 0x7d, 0xf3, - 0x16, 0x7a, 0x54, 0x7c, 0x21, 0x79, 0xb0, 0xb7, 0xec, 0xcf, 0xb0, 0x79, 0x9e, 0xf9, 0x5a, 0x1c, - 0xb2, 0xcb, 0x6e, 0xad, 0x5c, 0xd5, 0xbd, 0x37, 0xc9, 0xf7, 0xec, 0xce, 0x9b, 0xcc, 0xb9, 0x5b, - 0x37, 0xa7, 0x47, 0x98, 0xc9, 0x6e, 0xa7, 0xa1, 0xea, 0x30, 0xda, 0xf4, 0x38, 0x87, 0xbb, 0xe6, - 0xfc, 0x41, 0x9e, 0x2a, 0x35, 0xb1, 0x92, 0xe9, 0xbe, 0x20, 0x14, 0x20, 0x68, 0xb7, 0x7d, 0x34, - 0xb0, 0x85, 0xec, 0xe2, 0x9b, 0x79, 0xe6, 0xca, 0xa6, 0xf0, 0xeb, 0x31, 0xc8, 0x2c, 0xbb, 0x62, - 0x9f, 0x8b, 0xff, 0xcc, 0x9e, 0x28, 0x3c, 0xe6, 0xbf, 0x38, 0x12, 0xef, 0x2d, 0x10, 0xa2, 0x2f, - 0x93, 0x7c, 0x2b, 0x4e, 0xf3, 0x70, 0x09, 0xd7, 0x74, 0xd3, 0x5f, 0xac, 0xf1, 0x3b, 0x1b, 0xa3, - 0x1f, 0xa2, 0x8d, 0x51, 0x30, 0xc3, 0x89, 0x83, 0xcc, 0xf0, 0x6f, 0xc5, 0x60, 0x78, 0xd9, 0xad, - 0x6d, 0x9a, 0xd5, 0x77, 0x42, 0xe5, 0x8d, 0x84, 0xca, 0x6d, 0x2f, 0xcd, 0xbe, 0x1e, 0x83, 0x53, - 0xe1, 0x5a, 0xea, 0xd9, 0x06, 0x76, 0xf6, 0xfc, 0x72, 0xc9, 0x56, 0x6b, 0xba, 0x19, 0xbe, 0x3d, - 0x73, 0x24, 0x2c, 0x2c, 0xc5, 0x15, 0x22, 0xcb, 0x26, 0x64, 0xd6, 0xd4, 0x1a, 0x56, 0xf0, 0xb3, - 0x0d, 0xec, 0x7a, 0x6d, 0xde, 0x6d, 0x99, 0x84, 0x01, 0x6b, 0x7b, 0x9b, 0x5d, 0xb6, 0x90, 0x4e, - 0x26, 0x14, 0xde, 0x42, 0x13, 0x90, 0x34, 0xf4, 0xba, 0xce, 0x0c, 0x92, 0x50, 0x58, 0x03, 0x4d, - 0x43, 0x46, 0x23, 0x7a, 0x57, 0xd8, 0x95, 0xfd, 0x84, 0xf8, 0x76, 0x47, 0xc3, 0xf4, 0x36, 0x08, - 0x44, 0x7e, 0x02, 0x86, 0xd8, 0x78, 0x7c, 0x7f, 0x71, 0x04, 0x52, 0xf4, 0x8a, 0x75, 0x30, 0xea, - 0x20, 0x69, 0x5f, 0x66, 0xef, 0xc1, 0x30, 0x2e, 0x6c, 0x60, 0xd6, 0x28, 0x95, 0x3a, 0x9a, 0xf2, - 0x64, 0xf7, 0x49, 0x66, 0x86, 0xf2, 0xcd, 0xf8, 0x9b, 0x49, 0x38, 0xcc, 0xaf, 0xb5, 0xa8, 0xb6, - 0x3e, 0xb3, 0xe3, 0x79, 0xe2, 0x05, 0x33, 0xe0, 0x1b, 0x7b, 0xd5, 0xd6, 0xe5, 0x3d, 0x48, 0x5c, - 0xf4, 0x3c, 0x1b, 0x9d, 0x82, 0xa4, 0xd3, 0x30, 0xb0, 0x78, 0x58, 0x30, 0x51, 0x08, 0x70, 0x0a, - 0x04, 0x41, 0x69, 0x18, 0x58, 0x61, 0x28, 0xa8, 0x0c, 0xd3, 0xdb, 0x0d, 0xc3, 0xd8, 0xab, 0x54, - 0x31, 0xfd, 0x77, 0x4a, 0xfe, 0x7f, 0x2e, 0xc0, 0xbb, 0xb6, 0x6a, 0xfa, 0x45, 0x65, 0x4a, 0x39, - 0x46, 0xd1, 0xe6, 0x29, 0x96, 0xf8, 0xaf, 0x05, 0x65, 0x81, 0x23, 0xff, 0x7e, 0x0c, 0x52, 0x82, - 0x35, 0x7d, 0x31, 0x05, 0x1b, 0x58, 0xf3, 0x2c, 0x71, 0x41, 0xc1, 0x6f, 0x23, 0x04, 0xf1, 0x1a, - 0x9f, 0xa2, 0xf4, 0xc5, 0x43, 0x0a, 0x69, 0x10, 0x98, 0xff, 0xba, 0x10, 0x81, 0xd9, 0x0d, 0x32, - 0x6b, 0x09, 0xdb, 0x12, 0x27, 0x63, 0x17, 0x0f, 0x29, 0xb4, 0x85, 0x72, 0x30, 0x40, 0xa2, 0xcd, - 0x63, 0xdf, 0x94, 0x24, 0x70, 0xde, 0x46, 0x93, 0x90, 0xb4, 0x55, 0x4f, 0x63, 0xd7, 0xec, 0x49, - 0x07, 0x6b, 0x92, 0x78, 0x60, 0xef, 0xf2, 0x36, 0xff, 0xaf, 0x12, 0x62, 0x0c, 0xf6, 0xd1, 0x34, - 0x22, 0xf7, 0x9a, 0xea, 0x79, 0xd8, 0x31, 0x09, 0x43, 0x86, 0x4e, 0xdf, 0x41, 0xb3, 0xaa, 0x7b, - 0xfc, 0xff, 0xa7, 0xd0, 0xdf, 0xfc, 0x3f, 0x3b, 0x50, 0x7f, 0xa8, 0xd0, 0x4e, 0xf6, 0x6f, 0xa3, - 0x86, 0x04, 0xb0, 0x44, 0x90, 0xca, 0x30, 0xae, 0x56, 0xab, 0x3a, 0xf1, 0x6a, 0xd5, 0xa8, 0x6c, - 0xe9, 0xf4, 0xe0, 0xc4, 0xa5, 0xff, 0x14, 0xac, 0xd3, 0x5c, 0xa0, 0x80, 0xa0, 0xc4, 0xf1, 0x4b, - 0x69, 0x18, 0xb4, 0x99, 0x50, 0xf2, 0x79, 0x18, 0x6b, 0x91, 0x94, 0xc8, 0x77, 0x55, 0x37, 0xab, - 0xe2, 0x1d, 0x2a, 0xf2, 0x9b, 0xc0, 0xe8, 0x87, 0x0f, 0xd9, 0xd5, 0x0f, 0xfa, 0xbb, 0xf4, 0xe3, - 0x9d, 0xef, 0x90, 0x8d, 0x84, 0xee, 0x90, 0xa9, 0xb6, 0x5e, 0x4a, 0x53, 0xfe, 0xfc, 0xea, 0xd8, - 0x2c, 0xef, 0x60, 0xd7, 0xc6, 0x0a, 0x96, 0x53, 0x9b, 0xa9, 0x61, 0x53, 0xec, 0x94, 0x48, 0x97, - 0x6a, 0xeb, 0x2e, 0x75, 0xc7, 0xe0, 0x43, 0x8c, 0xee, 0xf9, 0xd0, 0x6f, 0x7a, 0xa3, 0x2c, 0xb1, - 0x30, 0xbb, 0xb6, 0xe8, 0xfb, 0xf1, 0x6f, 0xc4, 0xe0, 0x58, 0xc8, 0x8f, 0x43, 0xc8, 0xad, 0xee, - 0x9c, 0x6f, 0xef, 0xf1, 0x3d, 0x7c, 0xc6, 0xf0, 0x32, 0x24, 0x08, 0x3e, 0xea, 0xf2, 0x7f, 0x17, - 0x72, 0xbf, 0xf4, 0xcf, 0xff, 0x91, 0x4c, 0x9d, 0xa2, 0xfd, 0xac, 0x50, 0x26, 0xa5, 0x4f, 0xf4, - 0x6e, 0xbf, 0x6c, 0xf0, 0x0d, 0x4a, 0xf7, 0xf6, 0x99, 0xb1, 0xd9, 0x86, 0x9f, 0x3f, 0x0f, 0x72, - 0x87, 0xed, 0x27, 0xcb, 0x98, 0xfb, 0x6f, 0x78, 0xfb, 0x48, 0xc7, 0x9d, 0xee, 0xe7, 0xed, 0x37, - 0x83, 0x3d, 0x6e, 0x8d, 0x77, 0x61, 0xf2, 0x49, 0x32, 0x76, 0x70, 0x28, 0x28, 0x12, 0xfb, 0xa4, - 0x7f, 0x73, 0x46, 0xe2, 0xff, 0x93, 0x4d, 0x5c, 0x83, 0x81, 0x40, 0x3e, 0xbe, 0xd1, 0xbd, 0xa7, - 0xd0, 0x71, 0xbd, 0x28, 0x84, 0x16, 0x0b, 0x25, 0x44, 0x29, 0xff, 0x82, 0x04, 0x77, 0xb4, 0x0c, - 0xcd, 0x73, 0xfc, 0x02, 0x40, 0xe8, 0x54, 0x53, 0xea, 0xef, 0xce, 0x5e, 0x88, 0x94, 0x30, 0x6a, - 0x11, 0xf6, 0xde, 0xae, 0xc2, 0x32, 0x29, 0x22, 0xd2, 0x3e, 0x0b, 0x87, 0xa3, 0xc2, 0x0a, 0x33, - 0x3d, 0x0d, 0x23, 0xd1, 0x02, 0x82, 0x17, 0x37, 0x07, 0xb8, 0x7b, 0x31, 0x1c, 0x29, 0x22, 0xe4, - 0x4a, 0xf3, 0xd4, 0xf8, 0xe6, 0x29, 0x43, 0xda, 0x47, 0xe5, 0x5b, 0xc7, 0x9e, 0xad, 0x13, 0x50, - 0xca, 0x5f, 0x97, 0xe0, 0x44, 0x74, 0x84, 0x60, 0xe3, 0xe3, 0xbe, 0xe9, 0xfa, 0xdd, 0x36, 0x47, - 0xfa, 0xae, 0x04, 0x77, 0xee, 0xa3, 0x06, 0xb7, 0xd9, 0x0d, 0x98, 0x08, 0x9d, 0xae, 0x8a, 0x85, - 0x42, 0x38, 0xd7, 0xa9, 0xee, 0xc7, 0xc2, 0xfe, 0x61, 0xe2, 0x51, 0x62, 0xc7, 0xaf, 0x7c, 0x6b, - 0x7a, 0xbc, 0xb5, 0xcf, 0x55, 0xc6, 0x5b, 0x4f, 0x44, 0x6f, 0xa3, 0x17, 0xfe, 0xae, 0x04, 0xf7, - 0x45, 0x55, 0x6d, 0xf3, 0x0c, 0xf6, 0x6d, 0x34, 0x75, 0xff, 0x5e, 0x82, 0x53, 0xbd, 0xe8, 0xc3, - 0xe7, 0x70, 0x0b, 0xc6, 0x83, 0xc7, 0x22, 0xcd, 0x53, 0x78, 0x7f, 0x1f, 0x0f, 0xb7, 0x79, 0x2c, - 0x20, 0x9f, 0xdb, 0x9b, 0x30, 0x57, 0xff, 0x52, 0xe2, 0xf1, 0x1b, 0x76, 0x13, 0x7f, 0x62, 0xa2, - 0x1b, 0x9e, 0x3e, 0x27, 0x26, 0xb4, 0xe9, 0x19, 0x8e, 0x6c, 0x7a, 0xda, 0x4c, 0x79, 0xec, 0x36, - 0x65, 0xa3, 0x6b, 0x3c, 0x5b, 0xb7, 0x79, 0xce, 0xf2, 0x41, 0x18, 0x6f, 0x13, 0x5a, 0x3c, 0x31, - 0xf5, 0x11, 0x59, 0x0a, 0x6a, 0x0d, 0x1e, 0xf9, 0xdf, 0x48, 0x30, 0x4d, 0x07, 0x6e, 0x33, 0x8d, - 0x6f, 0x67, 0x7b, 0xd6, 0x79, 0xee, 0x6d, 0xab, 0x16, 0x37, 0xec, 0x22, 0x0c, 0x30, 0x0f, 0xe5, - 0xb6, 0x3c, 0x80, 0x8b, 0x73, 0x06, 0x41, 0xae, 0x9f, 0x17, 0xfa, 0xb5, 0x4f, 0x18, 0x6f, 0x92, - 0x1d, 0x6f, 0x57, 0xc2, 0x78, 0x45, 0xe4, 0xfa, 0xf6, 0x6a, 0x70, 0xbb, 0x69, 0xb7, 0x2d, 0xd7, - 0x33, 0x23, 0xbe, 0x45, 0x49, 0xdd, 0xd7, 0xa9, 0x4b, 0x52, 0xff, 0x21, 0x9f, 0x23, 0x3f, 0xa9, - 0x77, 0xd1, 0xe7, 0xed, 0x98, 0xd4, 0xff, 0x24, 0x06, 0x47, 0xa8, 0x6e, 0xe1, 0x67, 0x8d, 0x6f, - 0xc1, 0xdc, 0x54, 0x00, 0xb9, 0x8e, 0x56, 0xb9, 0x5d, 0xb9, 0x28, 0xeb, 0x3a, 0xda, 0x95, 0xc8, - 0x8a, 0x5e, 0x01, 0x54, 0x75, 0xbd, 0xe6, 0x01, 0xe2, 0x07, 0x1e, 0xa0, 0xea, 0x7a, 0x57, 0xf6, - 0x29, 0x19, 0x12, 0x07, 0xf6, 0xae, 0x97, 0x25, 0xc8, 0xb7, 0x9b, 0x01, 0xee, 0x4d, 0x3a, 0x4c, - 0x46, 0x1e, 0xa3, 0x37, 0x3b, 0xd4, 0x03, 0xbd, 0x3c, 0x3c, 0x6e, 0x0a, 0xff, 0xc3, 0x0e, 0x7e, - 0x53, 0x13, 0xc0, 0x3f, 0x13, 0x4b, 0x9c, 0x1f, 0x30, 0xad, 0xbb, 0xb1, 0x1f, 0xfe, 0xb0, 0xff, - 0x95, 0x96, 0x15, 0xe6, 0x6d, 0xb1, 0xb1, 0xfb, 0xa6, 0x04, 0x53, 0x1d, 0xc4, 0x7e, 0x3b, 0x97, - 0x17, 0x3b, 0x1d, 0x5d, 0xea, 0x76, 0xef, 0x22, 0xcf, 0xf0, 0x78, 0x8c, 0xbe, 0xaa, 0x17, 0x3a, - 0x45, 0x68, 0xf7, 0xf1, 0x01, 0xf9, 0xfd, 0x70, 0xb4, 0x2d, 0x15, 0x97, 0xad, 0x08, 0x89, 0x1d, - 0xdd, 0xf5, 0xb8, 0x58, 0xf7, 0x74, 0x12, 0xab, 0x89, 0x9a, 0xd2, 0xc8, 0x08, 0xb2, 0x94, 0xf5, - 0x9a, 0x65, 0x19, 0x5c, 0x0c, 0xf9, 0x32, 0x8c, 0x85, 0x60, 0x7c, 0x90, 0xb3, 0x90, 0xb0, 0x2d, - 0xfe, 0x3d, 0x9f, 0xcc, 0xe9, 0x63, 0x9d, 0x06, 0x21, 0x34, 0x5c, 0x6d, 0x8a, 0x2f, 0x4f, 0x00, - 0x62, 0xcc, 0xe8, 0x5d, 0x2f, 0x31, 0xc4, 0x3a, 0x8c, 0x47, 0xa0, 0x7c, 0x90, 0x77, 0xc3, 0x80, - 0x4d, 0x21, 0x7c, 0x98, 0x8e, 0x2f, 0x09, 0x30, 0x3a, 0x51, 0xb6, 0x31, 0x9a, 0xd3, 0xdf, 0x3b, - 0x0c, 0x49, 0xca, 0x15, 0x7d, 0x46, 0x02, 0x08, 0xdd, 0xdc, 0x2a, 0x74, 0x62, 0xd3, 0xfe, 0x34, - 0x27, 0x3f, 0xd3, 0x33, 0x3e, 0xaf, 0xbb, 0x4f, 0xfd, 0xf8, 0xbf, 0xfe, 0xce, 0xcf, 0xc4, 0xee, - 0x46, 0xf2, 0x4c, 0x87, 0x73, 0xa4, 0x50, 0x30, 0x7e, 0x59, 0x0a, 0xbf, 0x4b, 0xf6, 0x60, 0x6f, - 0x43, 0x09, 0xc9, 0x0a, 0xbd, 0xa2, 0x73, 0xc1, 0xce, 0x53, 0xc1, 0x1e, 0x45, 0x8f, 0x74, 0x17, - 0x6c, 0xe6, 0x43, 0xd1, 0xe8, 0xfa, 0x08, 0xfa, 0xa6, 0x04, 0x13, 0xed, 0x8e, 0x09, 0xd0, 0xb9, - 0xde, 0xa4, 0x68, 0x2d, 0xc8, 0xf2, 0x8f, 0x1f, 0x80, 0x92, 0xab, 0xb2, 0x40, 0x55, 0x99, 0x45, - 0x4f, 0x1c, 0x40, 0x95, 0x99, 0xd0, 0xea, 0x87, 0xfe, 0x9f, 0x04, 0xc7, 0xf7, 0xdd, 0x42, 0xa3, - 0xd9, 0xde, 0xa4, 0xdc, 0xa7, 0xf2, 0xcc, 0x97, 0xde, 0x08, 0x0b, 0xae, 0xf1, 0x93, 0x54, 0xe3, - 0xcb, 0x68, 0xf1, 0x20, 0x1a, 0x07, 0x65, 0x62, 0x58, 0xf7, 0xdf, 0x96, 0x22, 0xaf, 0x53, 0xec, - 0xef, 0x4e, 0x2d, 0x7b, 0xc7, 0x2e, 0x81, 0xd1, 0xba, 0x25, 0x90, 0x9f, 0xa6, 0x2a, 0x28, 0x68, - 0xed, 0x0d, 0x4e, 0xda, 0xcc, 0x87, 0xa2, 0x8b, 0xca, 0x47, 0xd0, 0xff, 0x91, 0xda, 0xbf, 0xbf, - 0xf0, 0xd8, 0xbe, 0x22, 0x76, 0xde, 0x17, 0xe7, 0xcf, 0xf5, 0x4f, 0xc8, 0x95, 0xac, 0x53, 0x25, - 0x6b, 0x08, 0xdf, 0x6e, 0x25, 0xdb, 0x4e, 0x22, 0xfa, 0x1d, 0x09, 0x26, 0xda, 0xed, 0xe8, 0xba, - 0x84, 0xe5, 0x3e, 0x7b, 0xd9, 0x2e, 0x61, 0xb9, 0xdf, 0xf6, 0x51, 0x7e, 0x37, 0x55, 0xfe, 0x2c, - 0x3a, 0xd3, 0x49, 0xf9, 0x7d, 0x67, 0x91, 0xc4, 0xe2, 0xbe, 0x3b, 0x9f, 0x2e, 0xb1, 0xd8, 0xcb, - 0x2e, 0xb0, 0x4b, 0x2c, 0xf6, 0xb4, 0xf1, 0xea, 0x1e, 0x8b, 0xbe, 0x66, 0x3d, 0x4e, 0xa3, 0x8b, - 0x7e, 0x43, 0x82, 0xe1, 0x48, 0x5d, 0x8e, 0x1e, 0xde, 0x57, 0xd0, 0x76, 0xbb, 0xa8, 0xfc, 0xe9, - 0x7e, 0x48, 0xb8, 0x2e, 0x8b, 0x54, 0x97, 0x39, 0x34, 0x7b, 0x10, 0x5d, 0x9c, 0x88, 0xc4, 0x2f, - 0x4b, 0x30, 0xde, 0xa6, 0x84, 0xed, 0x12, 0x85, 0x9d, 0x4b, 0xf7, 0xfc, 0xb9, 0xfe, 0x09, 0xb9, - 0x56, 0x17, 0xa8, 0x56, 0xef, 0x43, 0xef, 0x3d, 0x88, 0x56, 0xa1, 0xf5, 0xf9, 0x66, 0x70, 0x3f, - 0x3a, 0x34, 0x0e, 0x3a, 0xdb, 0xa7, 0x60, 0x42, 0xa1, 0xc7, 0xfa, 0xa6, 0xe3, 0xfa, 0x3c, 0x45, - 0xf5, 0x79, 0x12, 0xad, 0xbe, 0x31, 0x7d, 0x5a, 0x97, 0xf5, 0xaf, 0xb6, 0x7e, 0x2a, 0x62, 0x7f, - 0x2f, 0x6a, 0x5b, 0xac, 0xe6, 0x1f, 0xe9, 0x8b, 0x86, 0x2b, 0x75, 0x8e, 0x2a, 0x75, 0x1a, 0x3d, - 0xd4, 0x49, 0xa9, 0xd0, 0x25, 0x78, 0xdd, 0xdc, 0xb6, 0x66, 0x3e, 0xc4, 0x4a, 0xe0, 0x8f, 0xa0, - 0x1f, 0x13, 0x17, 0x90, 0x4f, 0xee, 0x3b, 0x6e, 0xa8, 0x8e, 0xcd, 0xdf, 0xd7, 0x03, 0x26, 0x97, - 0xeb, 0x6e, 0x2a, 0xd7, 0x14, 0x3a, 0xd6, 0x49, 0x2e, 0x52, 0xcb, 0xa2, 0x4f, 0x4a, 0xfe, 0x3b, - 0x0b, 0xa7, 0xf6, 0xe7, 0x1d, 0x2e, 0x76, 0xf3, 0xf7, 0xf7, 0x84, 0xcb, 0x25, 0xb9, 0x87, 0x4a, - 0x72, 0x02, 0x4d, 0x75, 0x94, 0x84, 0x95, 0xbe, 0xb7, 0xfb, 0xce, 0xcb, 0x67, 0x53, 0x1d, 0x3f, - 0x8b, 0x52, 0xc3, 0x26, 0x76, 0x75, 0xf7, 0x40, 0x77, 0x92, 0x7b, 0x7b, 0xb0, 0xfa, 0xcd, 0x24, - 0x0c, 0x2d, 0xb0, 0x51, 0xd6, 0x3d, 0xd5, 0x7b, 0x83, 0x1b, 0x01, 0xe4, 0xf2, 0x0f, 0x19, 0xd2, - 0x2b, 0x2d, 0x15, 0xdb, 0xba, 0x8e, 0xc5, 0x5e, 0x71, 0xb1, 0xef, 0xcb, 0xc0, 0xfc, 0xfd, 0xfc, - 0x66, 0x7e, 0x32, 0xfb, 0x26, 0x22, 0xbd, 0x75, 0xb3, 0x46, 0x00, 0xe8, 0x63, 0x12, 0x1c, 0xa6, - 0x58, 0x41, 0xbc, 0x51, 0x4c, 0xf1, 0x3e, 0x61, 0x47, 0x8f, 0x59, 0x52, 0x43, 0xc7, 0x3f, 0x94, - 0x57, 0xe9, 0x6e, 0xfe, 0x7a, 0xcb, 0xb1, 0xd0, 0xe0, 0xcd, 0x6c, 0x65, 0x65, 0xdc, 0x68, 0xa1, - 0x74, 0x9b, 0x0e, 0x0d, 0x12, 0x07, 0x3f, 0x34, 0xb8, 0x04, 0x99, 0x50, 0xa6, 0xcf, 0x25, 0xbb, - 0xbc, 0xc2, 0xdb, 0x7c, 0xb2, 0x18, 0x26, 0x46, 0x9f, 0x90, 0xe0, 0x70, 0xdb, 0x45, 0x90, 0xfe, - 0x1f, 0xce, 0x3e, 0x4f, 0x2e, 0x9b, 0x8c, 0xd3, 0x96, 0xaf, 0xac, 0x4c, 0x34, 0xda, 0x55, 0x13, - 0x6b, 0x30, 0x1c, 0x59, 0xc0, 0x72, 0xe2, 0xbf, 0xe9, 0xf6, 0xfe, 0xc2, 0x45, 0x94, 0x01, 0xca, - 0x43, 0x0a, 0xef, 0xda, 0x96, 0xe3, 0xe1, 0x2a, 0xbd, 0xac, 0x93, 0x52, 0xfc, 0xb6, 0x7c, 0x1d, - 0x50, 0xeb, 0xe4, 0xa2, 0xcb, 0x30, 0x18, 0xbd, 0xda, 0x77, 0x80, 0x03, 0x0c, 0xc1, 0x01, 0x4d, - 0x40, 0x32, 0xf0, 0xef, 0xb8, 0xc2, 0x1a, 0xb7, 0x3b, 0x39, 0xfc, 0x69, 0x00, 0x00, 0x00, 0xff, - 0xff, 0x75, 0x0a, 0xea, 0x1f, 0x47, 0x91, 0x00, 0x00, + // 9022 bytes of a gzipped FileDescriptorSet + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6b, 0x74, 0x1c, 0xe7, + 0x75, 0x18, 0x67, 0x1f, 0xc0, 0xee, 0xc5, 0x6b, 0xf1, 0x01, 0xa4, 0x96, 0x4b, 0x0a, 0x80, 0x46, + 0xb2, 0x44, 0x51, 0xd2, 0x42, 0xa2, 0x28, 0x92, 0x5a, 0xc6, 0x96, 0xb1, 0xc0, 0x12, 0x04, 0x89, + 0x97, 0x06, 0x20, 0x25, 0xdb, 0x49, 0xe7, 0x0c, 0x66, 0x3f, 0x2c, 0x46, 0x9c, 0x9d, 0x19, 0xcd, + 0xcc, 0x92, 0x00, 0x6d, 0x9f, 0xa3, 0xc4, 0x8f, 0xc6, 0x6a, 0x53, 0xdb, 0x4d, 0x4e, 0x6b, 0xbb, + 0x96, 0xeb, 0x47, 0x5b, 0xa7, 0x4e, 0xdb, 0x24, 0x75, 0x9a, 0x36, 0x4d, 0x4f, 0x6b, 0x37, 0x4e, + 0xe2, 0xb4, 0x4d, 0x8f, 0x7d, 0xea, 0xb6, 0x69, 0x4e, 0x4b, 0xa7, 0xb2, 0x4f, 0xeb, 0xb8, 0x6e, + 0x93, 0xb2, 0xea, 0x53, 0x3f, 0xd2, 0xf3, 0xbd, 0xe6, 0xb1, 0x0f, 0xec, 0x2e, 0x44, 0xc9, 0xd6, + 0x89, 0x7e, 0x61, 0xe6, 0xce, 0xbd, 0xf7, 0xbb, 0xf7, 0x7e, 0xf7, 0xde, 0xef, 0x7e, 0xaf, 0x05, + 0x7c, 0x2d, 0x01, 0x27, 0x75, 0xdb, 0xab, 0xdb, 0xde, 0xec, 0x96, 0xe6, 0xe1, 0xd9, 0xe7, 0x1b, + 0xd8, 0xdd, 0x9b, 0xbd, 0xfe, 0xd8, 0x16, 0xf6, 0xb5, 0xc7, 0x66, 0x1d, 0xad, 0x66, 0x58, 0x9a, + 0x6f, 0xd8, 0x56, 0xd1, 0x71, 0x6d, 0xdf, 0x46, 0x47, 0x19, 0x6e, 0x91, 0xe0, 0x16, 0x29, 0x6e, + 0x91, 0xe3, 0xca, 0x16, 0x0c, 0xad, 0x6b, 0x35, 0xac, 0xe0, 0xe7, 0x1b, 0xd8, 0xf3, 0x51, 0x0e, + 0x92, 0xd7, 0xf0, 0x5e, 0x5e, 0x9a, 0x91, 0x4e, 0x0c, 0x2b, 0xe4, 0x11, 0x1d, 0x81, 0x01, 0x7b, + 0x7b, 0xdb, 0xc3, 0x7e, 0x3e, 0x31, 0x23, 0x9d, 0x48, 0x29, 0xfc, 0x0d, 0x4d, 0x42, 0xda, 0x34, + 0xea, 0x86, 0x9f, 0x4f, 0x52, 0x30, 0x7b, 0x41, 0xd3, 0x30, 0xa4, 0xdb, 0x0d, 0xcb, 0x57, 0x7d, + 0xdb, 0xd7, 0xcc, 0x7c, 0x6a, 0x46, 0x3a, 0x91, 0x51, 0x80, 0x82, 0x36, 0x09, 0x44, 0x7e, 0x0a, + 0x86, 0x59, 0x7b, 0x9e, 0x63, 0x5b, 0x1e, 0x46, 0x47, 0x21, 0x63, 0xe1, 0x5d, 0x5f, 0x0d, 0x5b, + 0x1d, 0x24, 0xef, 0x97, 0xf1, 0x1e, 0x69, 0x81, 0x71, 0x61, 0x0d, 0xb3, 0x97, 0x72, 0xf9, 0xeb, + 0x2f, 0x4f, 0x49, 0xdf, 0x78, 0x79, 0x4a, 0xfa, 0x83, 0x97, 0xa7, 0xa4, 0x8f, 0x7d, 0x67, 0xea, + 0xd0, 0x37, 0xbe, 0x33, 0x75, 0xe8, 0xf7, 0xbe, 0x33, 0x75, 0xe8, 0xdd, 0x27, 0x6a, 0x86, 0xbf, + 0xd3, 0xd8, 0x2a, 0xea, 0x76, 0x7d, 0x96, 0x1b, 0x87, 0xfd, 0x79, 0xc4, 0xab, 0x5e, 0x9b, 0xf5, + 0xf7, 0x1c, 0xec, 0x31, 0x43, 0x6d, 0x0d, 0x50, 0xb3, 0x3c, 0x0e, 0xbf, 0x71, 0x1e, 0x66, 0x6a, + 0xb6, 0x5d, 0x33, 0xf1, 0x2c, 0x85, 0x6c, 0x35, 0xb6, 0x67, 0xab, 0xd8, 0xd3, 0x5d, 0xc3, 0xf1, + 0x6d, 0x97, 0x1b, 0x6f, 0x8c, 0x61, 0x14, 0x05, 0x86, 0xbc, 0x02, 0xe3, 0x17, 0x0c, 0x13, 0x2f, + 0x04, 0x88, 0x1b, 0xd8, 0x47, 0xe7, 0x20, 0xb5, 0x6d, 0x98, 0x38, 0x2f, 0xcd, 0x24, 0x4f, 0x0c, + 0x9d, 0xba, 0xaf, 0xd8, 0x44, 0x54, 0x8c, 0x53, 0xac, 0x13, 0xb0, 0x42, 0x29, 0xe4, 0xef, 0xa6, + 0x60, 0xa2, 0xcd, 0x57, 0x84, 0x20, 0x65, 0x69, 0x75, 0x4c, 0xad, 0x92, 0x55, 0xe8, 0x33, 0xca, + 0xc3, 0xa0, 0xa3, 0xe9, 0xd7, 0xb4, 0x1a, 0xa6, 0x46, 0xc9, 0x2a, 0xe2, 0x15, 0x4d, 0x01, 0x54, + 0xb1, 0x83, 0xad, 0x2a, 0xb6, 0xf4, 0xbd, 0x7c, 0x72, 0x26, 0x79, 0x22, 0xab, 0x44, 0x20, 0xe8, + 0x21, 0x18, 0x77, 0x1a, 0x5b, 0xa6, 0xa1, 0xab, 0x11, 0x34, 0x98, 0x49, 0x9e, 0x48, 0x2b, 0x39, + 0xf6, 0x61, 0x21, 0x44, 0x7e, 0x00, 0xc6, 0x6e, 0x60, 0xed, 0x5a, 0x14, 0x75, 0x88, 0xa2, 0x8e, + 0x12, 0x70, 0x04, 0x71, 0x1e, 0x86, 0xeb, 0xd8, 0xf3, 0xb4, 0x1a, 0x56, 0x89, 0x7d, 0xf3, 0x29, + 0xaa, 0xfd, 0x4c, 0x8b, 0xf6, 0xcd, 0x9a, 0x0f, 0x71, 0xaa, 0xcd, 0x3d, 0x07, 0xa3, 0x39, 0xc8, + 0x62, 0xab, 0x51, 0x67, 0x1c, 0xd2, 0x1d, 0xec, 0x57, 0xb1, 0x1a, 0xf5, 0x66, 0x2e, 0x19, 0x42, + 0xc6, 0x59, 0x0c, 0x7a, 0xd8, 0xbd, 0x6e, 0xe8, 0x38, 0x3f, 0x40, 0x19, 0x3c, 0xd0, 0xc2, 0x60, + 0x83, 0x7d, 0x6f, 0xe6, 0x21, 0xe8, 0xd0, 0x3c, 0x64, 0xf1, 0xae, 0x8f, 0x2d, 0xcf, 0xb0, 0xad, + 0xfc, 0x20, 0x65, 0xf2, 0xb6, 0x36, 0xbd, 0x88, 0xcd, 0x6a, 0x33, 0x8b, 0x90, 0x0e, 0x9d, 0x81, + 0x41, 0xdb, 0x21, 0x81, 0xe7, 0xe5, 0x33, 0x33, 0xd2, 0x89, 0xa1, 0x53, 0xc7, 0xdb, 0x3a, 0xc2, + 0x1a, 0xc3, 0x51, 0x04, 0x32, 0x5a, 0x82, 0x9c, 0x67, 0x37, 0x5c, 0x1d, 0xab, 0xba, 0x5d, 0xc5, + 0xaa, 0x61, 0x6d, 0xdb, 0xf9, 0x2c, 0x65, 0x30, 0xdd, 0xaa, 0x08, 0x45, 0x9c, 0xb7, 0xab, 0x78, + 0xc9, 0xda, 0xb6, 0x95, 0x51, 0x2f, 0xf6, 0x4e, 0xe2, 0xd5, 0xdb, 0xb3, 0x7c, 0x6d, 0x37, 0x3f, + 0x4c, 0x3d, 0x84, 0xbf, 0xc9, 0xbf, 0x36, 0x00, 0x63, 0xbd, 0xb8, 0xd8, 0x79, 0x48, 0x6f, 0x13, + 0x2d, 0xf3, 0x89, 0x7e, 0x6c, 0xc0, 0x68, 0xe2, 0x46, 0x1c, 0x38, 0xa0, 0x11, 0xe7, 0x60, 0xc8, + 0xc2, 0x9e, 0x8f, 0xab, 0xcc, 0x23, 0x92, 0x3d, 0xfa, 0x14, 0x30, 0xa2, 0x56, 0x97, 0x4a, 0x1d, + 0xc8, 0xa5, 0x9e, 0x85, 0xb1, 0x40, 0x24, 0xd5, 0xd5, 0xac, 0x9a, 0xf0, 0xcd, 0xd9, 0x6e, 0x92, + 0x14, 0x2b, 0x82, 0x4e, 0x21, 0x64, 0xca, 0x28, 0x8e, 0xbd, 0xa3, 0x05, 0x00, 0xdb, 0xc2, 0xf6, + 0xb6, 0x5a, 0xc5, 0xba, 0x99, 0xcf, 0x74, 0xb0, 0xd2, 0x1a, 0x41, 0x69, 0xb1, 0x92, 0xcd, 0xa0, + 0xba, 0x89, 0x9e, 0x0c, 0x5d, 0x6d, 0xb0, 0x83, 0xa7, 0xac, 0xb0, 0x20, 0x6b, 0xf1, 0xb6, 0x2b, + 0x30, 0xea, 0x62, 0xe2, 0xf7, 0xb8, 0xca, 0x35, 0xcb, 0x52, 0x21, 0x8a, 0x5d, 0x35, 0x53, 0x38, + 0x19, 0x53, 0x6c, 0xc4, 0x8d, 0xbe, 0xa2, 0x7b, 0x21, 0x00, 0xa8, 0xd4, 0xad, 0x80, 0x66, 0xa1, + 0x61, 0x01, 0x5c, 0xd5, 0xea, 0xb8, 0x70, 0x13, 0x46, 0xe3, 0xe6, 0x21, 0x69, 0xde, 0xf3, 0x35, + 0xd7, 0xa7, 0x5e, 0x98, 0x56, 0xd8, 0x0b, 0x19, 0x88, 0xb0, 0x55, 0xa5, 0x59, 0x2e, 0xad, 0x90, + 0x47, 0xf4, 0xce, 0x50, 0xe1, 0x24, 0x55, 0xf8, 0xfe, 0xd6, 0x1e, 0x8d, 0x71, 0x6e, 0xd6, 0xbb, + 0x70, 0x16, 0x46, 0x62, 0x0a, 0xf4, 0xda, 0xb4, 0xfc, 0x3e, 0x38, 0xdc, 0x96, 0x35, 0x7a, 0x16, + 0x26, 0x1b, 0x96, 0x61, 0xf9, 0xd8, 0x75, 0x5c, 0x4c, 0x3c, 0x96, 0x35, 0x95, 0xff, 0xcf, 0x83, + 0x1d, 0x7c, 0xee, 0x4a, 0x14, 0x9b, 0x71, 0x51, 0x26, 0x1a, 0xad, 0xc0, 0x93, 0xd9, 0xcc, 0xf7, + 0x06, 0x73, 0x2f, 0xbc, 0xf0, 0xc2, 0x0b, 0x09, 0xf9, 0xab, 0x03, 0x30, 0xd9, 0x2e, 0x66, 0xda, + 0x86, 0xef, 0x11, 0x18, 0xb0, 0x1a, 0xf5, 0x2d, 0xec, 0x52, 0x23, 0xa5, 0x15, 0xfe, 0x86, 0xe6, + 0x20, 0x6d, 0x6a, 0x5b, 0x98, 0x0d, 0xc9, 0xa3, 0xa7, 0x1e, 0xea, 0x29, 0x2a, 0x8b, 0xcb, 0x84, + 0x44, 0x61, 0x94, 0xe8, 0x1d, 0x90, 0xe2, 0x29, 0x9a, 0x70, 0x38, 0xd9, 0x1b, 0x07, 0x12, 0x4b, + 0x0a, 0xa5, 0x43, 0xc7, 0x20, 0x4b, 0xfe, 0x32, 0xdf, 0x18, 0xa0, 0x32, 0x67, 0x08, 0x80, 0xf8, + 0x05, 0x2a, 0x40, 0x86, 0x86, 0x49, 0x15, 0x8b, 0xa1, 0x2d, 0x78, 0x27, 0x8e, 0x55, 0xc5, 0xdb, + 0x5a, 0xc3, 0xf4, 0xd5, 0xeb, 0x9a, 0xd9, 0xc0, 0xd4, 0xe1, 0xb3, 0xca, 0x30, 0x07, 0x5e, 0x25, + 0x30, 0x52, 0x79, 0xb0, 0xa8, 0x32, 0xac, 0x2a, 0xde, 0xa5, 0xd9, 0x33, 0xad, 0xb0, 0x40, 0x5b, + 0x22, 0x10, 0xd2, 0xfc, 0x73, 0x9e, 0x6d, 0x09, 0xd7, 0xa4, 0x4d, 0x10, 0x00, 0x6d, 0xfe, 0x6c, + 0x73, 0xe2, 0xbe, 0xbb, 0xbd, 0x7a, 0x2d, 0xb1, 0xf4, 0x00, 0x8c, 0xb1, 0x62, 0x82, 0x77, 0xbd, + 0x66, 0xe6, 0xc7, 0x69, 0xd1, 0x33, 0xca, 0xc0, 0x6b, 0x1c, 0x2a, 0xff, 0x6a, 0x02, 0x52, 0x34, + 0xb1, 0x8c, 0xc1, 0xd0, 0xe6, 0xbb, 0xd6, 0x2b, 0xea, 0xc2, 0xda, 0x95, 0xf2, 0x72, 0x25, 0x27, + 0xa1, 0x51, 0x00, 0x0a, 0xb8, 0xb0, 0xbc, 0x36, 0xb7, 0x99, 0x4b, 0x04, 0xef, 0x4b, 0xab, 0x9b, + 0x67, 0x4e, 0xe7, 0x92, 0x01, 0xc1, 0x15, 0x06, 0x48, 0x45, 0x11, 0x1e, 0x3f, 0x95, 0x4b, 0xa3, + 0x1c, 0x0c, 0x33, 0x06, 0x4b, 0xcf, 0x56, 0x16, 0xce, 0x9c, 0xce, 0x0d, 0xc4, 0x21, 0x8f, 0x9f, + 0xca, 0x0d, 0xa2, 0x11, 0xc8, 0x52, 0x48, 0x79, 0x6d, 0x6d, 0x39, 0x97, 0x09, 0x78, 0x6e, 0x6c, + 0x2a, 0x4b, 0xab, 0x8b, 0xb9, 0x6c, 0xc0, 0x73, 0x51, 0x59, 0xbb, 0xb2, 0x9e, 0x83, 0x80, 0xc3, + 0x4a, 0x65, 0x63, 0x63, 0x6e, 0xb1, 0x92, 0x1b, 0x0a, 0x30, 0xca, 0xef, 0xda, 0xac, 0x6c, 0xe4, + 0x86, 0x63, 0x62, 0x3d, 0x7e, 0x2a, 0x37, 0x12, 0x34, 0x51, 0x59, 0xbd, 0xb2, 0x92, 0x1b, 0x45, + 0xe3, 0x30, 0xc2, 0x9a, 0x10, 0x42, 0x8c, 0x35, 0x81, 0xce, 0x9c, 0xce, 0xe5, 0x42, 0x41, 0x18, + 0x97, 0xf1, 0x18, 0xe0, 0xcc, 0xe9, 0x1c, 0x92, 0xe7, 0x21, 0x4d, 0xdd, 0x10, 0x21, 0x18, 0x5d, + 0x9e, 0x2b, 0x57, 0x96, 0xd5, 0xb5, 0xf5, 0xcd, 0xa5, 0xb5, 0xd5, 0xb9, 0xe5, 0x9c, 0x14, 0xc2, + 0x94, 0xca, 0xd3, 0x57, 0x96, 0x94, 0xca, 0x42, 0x2e, 0x11, 0x85, 0xad, 0x57, 0xe6, 0x36, 0x2b, + 0x0b, 0xb9, 0xa4, 0xac, 0xc3, 0x64, 0xbb, 0x84, 0xda, 0x36, 0x84, 0x22, 0xbe, 0x90, 0xe8, 0xe0, + 0x0b, 0x94, 0x57, 0xb3, 0x2f, 0xc8, 0xdf, 0x49, 0xc0, 0x44, 0x9b, 0x41, 0xa5, 0x6d, 0x23, 0x4f, + 0x41, 0x9a, 0xf9, 0x32, 0x1b, 0x66, 0x1f, 0x6c, 0x3b, 0x3a, 0x51, 0xcf, 0x6e, 0x19, 0x6a, 0x29, + 0x5d, 0xb4, 0xd4, 0x48, 0x76, 0x28, 0x35, 0x08, 0x8b, 0x16, 0x87, 0xfd, 0x89, 0x96, 0xe4, 0xcf, + 0xc6, 0xc7, 0x33, 0xbd, 0x8c, 0x8f, 0x14, 0xd6, 0xdf, 0x20, 0x90, 0x6e, 0x33, 0x08, 0x9c, 0x87, + 0xf1, 0x16, 0x46, 0x3d, 0x27, 0xe3, 0x0f, 0x48, 0x90, 0xef, 0x64, 0x9c, 0x2e, 0x29, 0x31, 0x11, + 0x4b, 0x89, 0xe7, 0x9b, 0x2d, 0x78, 0x4f, 0xe7, 0x4e, 0x68, 0xe9, 0xeb, 0x2f, 0x4a, 0x70, 0xa4, + 0x7d, 0x49, 0xd9, 0x56, 0x86, 0x77, 0xc0, 0x40, 0x1d, 0xfb, 0x3b, 0xb6, 0x28, 0xab, 0xee, 0x6f, + 0x33, 0x58, 0x93, 0xcf, 0xcd, 0x9d, 0xcd, 0xa9, 0xa2, 0xa3, 0x7d, 0xb2, 0x53, 0x5d, 0xc8, 0xa4, + 0x69, 0x91, 0xf4, 0x23, 0x09, 0x38, 0xdc, 0x96, 0x79, 0x5b, 0x41, 0xef, 0x06, 0x30, 0x2c, 0xa7, + 0xe1, 0xb3, 0xd2, 0x89, 0x65, 0xe2, 0x2c, 0x85, 0xd0, 0xe4, 0x45, 0xb2, 0x6c, 0xc3, 0x0f, 0xbe, + 0x27, 0xe9, 0x77, 0x60, 0x20, 0x8a, 0x70, 0x2e, 0x14, 0x34, 0x45, 0x05, 0x9d, 0xea, 0xa0, 0x69, + 0x8b, 0x63, 0x3e, 0x0a, 0x39, 0xdd, 0x34, 0xb0, 0xe5, 0xab, 0x9e, 0xef, 0x62, 0xad, 0x6e, 0x58, + 0x35, 0x3a, 0xd4, 0x64, 0x4a, 0xe9, 0x6d, 0xcd, 0xf4, 0xb0, 0x32, 0xc6, 0x3e, 0x6f, 0x88, 0xaf, + 0x84, 0x82, 0x3a, 0x90, 0x1b, 0xa1, 0x18, 0x88, 0x51, 0xb0, 0xcf, 0x01, 0x85, 0xfc, 0xf1, 0x2c, + 0x0c, 0x45, 0x0a, 0x70, 0x74, 0x0f, 0x0c, 0x3f, 0xa7, 0x5d, 0xd7, 0x54, 0x31, 0xa9, 0x62, 0x96, + 0x18, 0x22, 0xb0, 0x75, 0x3e, 0xb1, 0x7a, 0x14, 0x26, 0x29, 0x8a, 0xdd, 0xf0, 0xb1, 0xab, 0xea, + 0xa6, 0xe6, 0x79, 0xd4, 0x68, 0x19, 0x8a, 0x8a, 0xc8, 0xb7, 0x35, 0xf2, 0x69, 0x5e, 0x7c, 0x41, + 0x4f, 0xc0, 0x04, 0xa5, 0xa8, 0x37, 0x4c, 0xdf, 0x70, 0x4c, 0xac, 0x92, 0x69, 0x9e, 0x47, 0x87, + 0x9c, 0x40, 0xb2, 0x71, 0x82, 0xb1, 0xc2, 0x11, 0x88, 0x44, 0x1e, 0x5a, 0x80, 0xbb, 0x29, 0x59, + 0x0d, 0x5b, 0xd8, 0xd5, 0x7c, 0xac, 0xe2, 0xe7, 0x1b, 0x9a, 0xe9, 0xa9, 0x9a, 0x55, 0x55, 0x77, + 0x34, 0x6f, 0x27, 0x3f, 0x49, 0x18, 0x94, 0x13, 0x79, 0x49, 0x39, 0x4a, 0x10, 0x17, 0x39, 0x5e, + 0x85, 0xa2, 0xcd, 0x59, 0xd5, 0x8b, 0x9a, 0xb7, 0x83, 0x4a, 0x70, 0x84, 0x72, 0xf1, 0x7c, 0xd7, + 0xb0, 0x6a, 0xaa, 0xbe, 0x83, 0xf5, 0x6b, 0x6a, 0xc3, 0xdf, 0x3e, 0x97, 0x3f, 0x16, 0x6d, 0x9f, + 0x4a, 0xb8, 0x41, 0x71, 0xe6, 0x09, 0xca, 0x15, 0x7f, 0xfb, 0x1c, 0xda, 0x80, 0x61, 0xd2, 0x19, + 0x75, 0xe3, 0x26, 0x56, 0xb7, 0x6d, 0x97, 0x8e, 0xa1, 0xa3, 0x6d, 0x52, 0x53, 0xc4, 0x82, 0xc5, + 0x35, 0x4e, 0xb0, 0x62, 0x57, 0x71, 0x29, 0xbd, 0xb1, 0x5e, 0xa9, 0x2c, 0x28, 0x43, 0x82, 0xcb, + 0x05, 0xdb, 0x25, 0x0e, 0x55, 0xb3, 0x03, 0x03, 0x0f, 0x31, 0x87, 0xaa, 0xd9, 0xc2, 0xbc, 0x4f, + 0xc0, 0x84, 0xae, 0x33, 0x9d, 0x0d, 0x5d, 0xe5, 0x93, 0x31, 0x2f, 0x9f, 0x8b, 0x19, 0x4b, 0xd7, + 0x17, 0x19, 0x02, 0xf7, 0x71, 0x0f, 0x3d, 0x09, 0x87, 0x43, 0x63, 0x45, 0x09, 0xc7, 0x5b, 0xb4, + 0x6c, 0x26, 0x7d, 0x02, 0x26, 0x9c, 0xbd, 0x56, 0x42, 0x14, 0x6b, 0xd1, 0xd9, 0x6b, 0x26, 0x3b, + 0x0b, 0x93, 0xce, 0x8e, 0xd3, 0x4a, 0x77, 0x32, 0x4a, 0x87, 0x9c, 0x1d, 0xa7, 0x99, 0xf0, 0x6d, + 0x74, 0x66, 0xee, 0x62, 0x5d, 0xf3, 0x71, 0x35, 0x7f, 0x57, 0x14, 0x3d, 0xf2, 0x01, 0x15, 0x21, + 0xa7, 0xeb, 0x2a, 0xb6, 0xb4, 0x2d, 0x13, 0xab, 0x9a, 0x8b, 0x2d, 0xcd, 0xcb, 0x4f, 0x53, 0xe4, + 0x94, 0xef, 0x36, 0xb0, 0x32, 0xaa, 0xeb, 0x15, 0xfa, 0x71, 0x8e, 0x7e, 0x43, 0x27, 0x61, 0xdc, + 0xde, 0x7a, 0x4e, 0x67, 0x1e, 0xa9, 0x3a, 0x2e, 0xde, 0x36, 0x76, 0xf3, 0xf7, 0x51, 0xf3, 0x8e, + 0x91, 0x0f, 0xd4, 0x1f, 0xd7, 0x29, 0x18, 0x3d, 0x08, 0x39, 0xdd, 0xdb, 0xd1, 0x5c, 0x87, 0xa6, + 0x64, 0xcf, 0xd1, 0x74, 0x9c, 0x7f, 0x1b, 0x43, 0x65, 0xf0, 0x55, 0x01, 0x26, 0x11, 0xe1, 0xdd, + 0x30, 0xb6, 0x7d, 0xc1, 0xf1, 0x01, 0x16, 0x11, 0x14, 0xc6, 0xb9, 0x9d, 0x80, 0x1c, 0xb1, 0x44, + 0xac, 0xe1, 0x13, 0x14, 0x6d, 0xd4, 0xd9, 0x71, 0xa2, 0xed, 0xde, 0x0b, 0x23, 0x04, 0x33, 0x6c, + 0xf4, 0x41, 0x56, 0xb8, 0x39, 0x3b, 0x91, 0x16, 0x4f, 0xc3, 0x11, 0x82, 0x54, 0xc7, 0xbe, 0x56, + 0xd5, 0x7c, 0x2d, 0x82, 0xfd, 0x30, 0xc5, 0x26, 0x66, 0x5f, 0xe1, 0x1f, 0x63, 0x72, 0xba, 0x8d, + 0xad, 0xbd, 0xc0, 0xb1, 0x1e, 0x61, 0x72, 0x12, 0x98, 0x70, 0xad, 0xd7, 0xad, 0x38, 0x97, 0x4b, + 0x30, 0x1c, 0xf5, 0x7b, 0x94, 0x05, 0xe6, 0xf9, 0x39, 0x89, 0x14, 0x41, 0xf3, 0x6b, 0x0b, 0xa4, + 0x7c, 0x79, 0x77, 0x25, 0x97, 0x20, 0x65, 0xd4, 0xf2, 0xd2, 0x66, 0x45, 0x55, 0xae, 0xac, 0x6e, + 0x2e, 0xad, 0x54, 0x72, 0xc9, 0x48, 0x61, 0x7f, 0x29, 0x95, 0xb9, 0x3f, 0xf7, 0x80, 0xfc, 0xcd, + 0x04, 0x8c, 0xc6, 0x67, 0x6a, 0xe8, 0xc7, 0xe0, 0x2e, 0xb1, 0xac, 0xe2, 0x61, 0x5f, 0xbd, 0x61, + 0xb8, 0x34, 0x20, 0xeb, 0x1a, 0x1b, 0x1c, 0x03, 0xff, 0x99, 0xe4, 0x58, 0x1b, 0xd8, 0x7f, 0xc6, + 0x70, 0x49, 0xb8, 0xd5, 0x35, 0x1f, 0x2d, 0xc3, 0xb4, 0x65, 0xab, 0x9e, 0xaf, 0x59, 0x55, 0xcd, + 0xad, 0xaa, 0xe1, 0x82, 0x96, 0xaa, 0xe9, 0x3a, 0xf6, 0x3c, 0x9b, 0x0d, 0x84, 0x01, 0x97, 0xe3, + 0x96, 0xbd, 0xc1, 0x91, 0xc3, 0x11, 0x62, 0x8e, 0xa3, 0x36, 0xb9, 0x6f, 0xb2, 0x93, 0xfb, 0x1e, + 0x83, 0x6c, 0x5d, 0x73, 0x54, 0x6c, 0xf9, 0xee, 0x1e, 0xad, 0xcf, 0x33, 0x4a, 0xa6, 0xae, 0x39, + 0x15, 0xf2, 0xfe, 0x86, 0x4c, 0x93, 0x2e, 0xa5, 0x32, 0x99, 0x5c, 0xf6, 0x52, 0x2a, 0x93, 0xcd, + 0x81, 0xfc, 0x72, 0x12, 0x86, 0xa3, 0xf5, 0x3a, 0x99, 0xfe, 0xe8, 0x74, 0xc4, 0x92, 0x68, 0x4e, + 0xbb, 0x77, 0xdf, 0xea, 0xbe, 0x38, 0x4f, 0x86, 0xb2, 0xd2, 0x00, 0x2b, 0x8e, 0x15, 0x46, 0x49, + 0xca, 0x08, 0xe2, 0x6c, 0x98, 0x15, 0x23, 0x19, 0x85, 0xbf, 0xa1, 0x45, 0x18, 0x78, 0xce, 0xa3, + 0xbc, 0x07, 0x28, 0xef, 0xfb, 0xf6, 0xe7, 0x7d, 0x69, 0x83, 0x32, 0xcf, 0x5e, 0xda, 0x50, 0x57, + 0xd7, 0x94, 0x95, 0xb9, 0x65, 0x85, 0x93, 0xa3, 0xa3, 0x90, 0x32, 0xb5, 0x9b, 0x7b, 0xf1, 0x41, + 0x8f, 0x82, 0x7a, 0xed, 0x84, 0xa3, 0x90, 0xba, 0x81, 0xb5, 0x6b, 0xf1, 0xa1, 0x86, 0x82, 0x5e, + 0xc7, 0x60, 0x98, 0x85, 0x34, 0xb5, 0x17, 0x02, 0xe0, 0x16, 0xcb, 0x1d, 0x42, 0x19, 0x48, 0xcd, + 0xaf, 0x29, 0x24, 0x20, 0x72, 0x30, 0xcc, 0xa0, 0xea, 0xfa, 0x52, 0x65, 0xbe, 0x92, 0x4b, 0xc8, + 0x4f, 0xc0, 0x00, 0x33, 0x02, 0x09, 0x96, 0xc0, 0x0c, 0xb9, 0x43, 0xfc, 0x95, 0xf3, 0x90, 0xc4, + 0xd7, 0x2b, 0x2b, 0xe5, 0x8a, 0x92, 0x4b, 0xc4, 0xbb, 0x3a, 0x95, 0x4b, 0xcb, 0x1e, 0x0c, 0x47, + 0xeb, 0xf0, 0x37, 0x66, 0x32, 0xfe, 0x15, 0x09, 0x86, 0x22, 0x75, 0x35, 0x29, 0x88, 0x34, 0xd3, + 0xb4, 0x6f, 0xa8, 0x9a, 0x69, 0x68, 0x1e, 0x77, 0x0d, 0xa0, 0xa0, 0x39, 0x02, 0xe9, 0xb5, 0xeb, + 0xde, 0xa0, 0x10, 0x49, 0xe7, 0x06, 0xe4, 0xcf, 0x48, 0x90, 0x6b, 0x2e, 0x6c, 0x9b, 0xc4, 0x94, + 0x7e, 0x98, 0x62, 0xca, 0x9f, 0x96, 0x60, 0x34, 0x5e, 0xcd, 0x36, 0x89, 0x77, 0xcf, 0x0f, 0x55, + 0xbc, 0x3f, 0x48, 0xc0, 0x48, 0xac, 0x86, 0xed, 0x55, 0xba, 0xe7, 0x61, 0xdc, 0xa8, 0xe2, 0xba, + 0x63, 0xfb, 0xd8, 0xd2, 0xf7, 0x54, 0x13, 0x5f, 0xc7, 0x66, 0x5e, 0xa6, 0x49, 0x63, 0x76, 0xff, + 0x2a, 0xb9, 0xb8, 0x14, 0xd2, 0x2d, 0x13, 0xb2, 0xd2, 0xc4, 0xd2, 0x42, 0x65, 0x65, 0x7d, 0x6d, + 0xb3, 0xb2, 0x3a, 0xff, 0x2e, 0xf5, 0xca, 0xea, 0xe5, 0xd5, 0xb5, 0x67, 0x56, 0x95, 0x9c, 0xd1, + 0x84, 0xf6, 0x3a, 0x86, 0xfd, 0x3a, 0xe4, 0x9a, 0x85, 0x42, 0x77, 0x41, 0x3b, 0xb1, 0x72, 0x87, + 0xd0, 0x04, 0x8c, 0xad, 0xae, 0xa9, 0x1b, 0x4b, 0x0b, 0x15, 0xb5, 0x72, 0xe1, 0x42, 0x65, 0x7e, + 0x73, 0x83, 0xad, 0x7b, 0x04, 0xd8, 0x9b, 0xb1, 0x00, 0x97, 0x3f, 0x95, 0x84, 0x89, 0x36, 0x92, + 0xa0, 0x39, 0x3e, 0x63, 0x61, 0x93, 0xa8, 0x47, 0x7a, 0x91, 0xbe, 0x48, 0x6a, 0x86, 0x75, 0xcd, + 0xf5, 0xf9, 0x04, 0xe7, 0x41, 0x20, 0x56, 0xb2, 0x7c, 0x63, 0xdb, 0xc0, 0x2e, 0x5f, 0x4f, 0x62, + 0xd3, 0x98, 0xb1, 0x10, 0xce, 0x96, 0x94, 0x1e, 0x06, 0xe4, 0xd8, 0x9e, 0xe1, 0x1b, 0xd7, 0xb1, + 0x6a, 0x58, 0x62, 0xf1, 0x29, 0x45, 0x77, 0xa3, 0x72, 0xe2, 0xcb, 0x92, 0xe5, 0x07, 0xd8, 0x16, + 0xae, 0x69, 0x4d, 0xd8, 0x24, 0x99, 0x27, 0x95, 0x9c, 0xf8, 0x12, 0x60, 0xdf, 0x03, 0xc3, 0x55, + 0xbb, 0x41, 0x6a, 0x3d, 0x86, 0x47, 0xc6, 0x0e, 0x49, 0x19, 0x62, 0xb0, 0x00, 0x85, 0x57, 0xf1, + 0xe1, 0xaa, 0xd7, 0xb0, 0x32, 0xc4, 0x60, 0x0c, 0xe5, 0x01, 0x18, 0xd3, 0x6a, 0x35, 0x97, 0x30, + 0x17, 0x8c, 0xd8, 0xbc, 0x64, 0x34, 0x00, 0x53, 0xc4, 0xc2, 0x25, 0xc8, 0x08, 0x3b, 0x90, 0xa1, + 0x9a, 0x58, 0x42, 0x75, 0xd8, 0x64, 0x3b, 0x71, 0x22, 0xab, 0x64, 0x2c, 0xf1, 0xf1, 0x1e, 0x18, + 0x36, 0x3c, 0x35, 0x5c, 0xc4, 0x4f, 0xcc, 0x24, 0x4e, 0x64, 0x94, 0x21, 0xc3, 0x0b, 0x16, 0x40, + 0xe5, 0x2f, 0x26, 0x60, 0x34, 0xbe, 0x09, 0x81, 0x16, 0x20, 0x63, 0xda, 0x3a, 0xdd, 0x72, 0xe4, + 0x3b, 0x60, 0x27, 0xba, 0xec, 0x5b, 0x14, 0x97, 0x39, 0xbe, 0x12, 0x50, 0x16, 0xfe, 0xa5, 0x04, + 0x19, 0x01, 0x46, 0x47, 0x20, 0xe5, 0x68, 0xfe, 0x0e, 0x65, 0x97, 0x2e, 0x27, 0x72, 0x92, 0x42, + 0xdf, 0x09, 0xdc, 0x73, 0x34, 0x8b, 0xba, 0x00, 0x87, 0x93, 0x77, 0xd2, 0xaf, 0x26, 0xd6, 0xaa, + 0x74, 0xd2, 0x63, 0xd7, 0xeb, 0xd8, 0xf2, 0x3d, 0xd1, 0xaf, 0x1c, 0x3e, 0xcf, 0xc1, 0xe8, 0x21, + 0x18, 0xf7, 0x5d, 0xcd, 0x30, 0x63, 0xb8, 0x29, 0x8a, 0x9b, 0x13, 0x1f, 0x02, 0xe4, 0x12, 0x1c, + 0x15, 0x7c, 0xab, 0xd8, 0xd7, 0xf4, 0x1d, 0x5c, 0x0d, 0x89, 0x06, 0xe8, 0xe2, 0xc6, 0x5d, 0x1c, + 0x61, 0x81, 0x7f, 0x17, 0xb4, 0xf2, 0x37, 0x25, 0x18, 0x17, 0xd3, 0xb4, 0x6a, 0x60, 0xac, 0x15, + 0x00, 0xcd, 0xb2, 0x6c, 0x3f, 0x6a, 0xae, 0x56, 0x57, 0x6e, 0xa1, 0x2b, 0xce, 0x05, 0x44, 0x4a, + 0x84, 0x41, 0xa1, 0x0e, 0x10, 0x7e, 0xe9, 0x68, 0xb6, 0x69, 0x18, 0xe2, 0x3b, 0x4c, 0x74, 0x9b, + 0x92, 0x4d, 0xec, 0x81, 0x81, 0xc8, 0x7c, 0x0e, 0x4d, 0x42, 0x7a, 0x0b, 0xd7, 0x0c, 0x8b, 0xaf, + 0x1b, 0xb3, 0x17, 0xb1, 0xfc, 0x92, 0x0a, 0x96, 0x5f, 0xca, 0x1f, 0x95, 0x60, 0x42, 0xb7, 0xeb, + 0xcd, 0xf2, 0x96, 0x73, 0x4d, 0xab, 0x0b, 0xde, 0x45, 0xe9, 0xdd, 0xef, 0x88, 0xec, 0xc8, 0xd6, + 0x6c, 0x53, 0xb3, 0x6a, 0xe1, 0x3e, 0x2b, 0x7d, 0xd0, 0x1f, 0xa9, 0x61, 0xeb, 0x91, 0x9a, 0x1d, + 0xd9, 0x75, 0x3d, 0x1f, 0x3e, 0xfe, 0x1f, 0x49, 0xfa, 0x7c, 0x22, 0xb9, 0xb8, 0x5e, 0xfe, 0x52, + 0xa2, 0xb0, 0xc8, 0x9a, 0x5b, 0x17, 0xe6, 0x51, 0xf0, 0xb6, 0x89, 0x75, 0xa2, 0x32, 0x7c, 0xff, + 0x21, 0x98, 0xac, 0xd9, 0x35, 0x9b, 0x72, 0x9c, 0x25, 0x4f, 0x7c, 0xe7, 0x36, 0x1b, 0x40, 0x0b, + 0x5d, 0xb7, 0x79, 0x4b, 0xab, 0x30, 0xc1, 0x91, 0x55, 0xba, 0x75, 0xc4, 0x26, 0x36, 0x68, 0xdf, + 0x55, 0xb5, 0xfc, 0x2f, 0x7f, 0x97, 0x0e, 0xe8, 0xca, 0x38, 0x27, 0x25, 0xdf, 0xd8, 0xdc, 0xa7, + 0xa4, 0xc0, 0xe1, 0x18, 0x3f, 0x16, 0xb6, 0xd8, 0xed, 0xc2, 0xf1, 0x37, 0x39, 0xc7, 0x89, 0x08, + 0xc7, 0x0d, 0x4e, 0x5a, 0x9a, 0x87, 0x91, 0x7e, 0x78, 0xfd, 0x16, 0xe7, 0x35, 0x8c, 0xa3, 0x4c, + 0x16, 0x61, 0x8c, 0x32, 0xd1, 0x1b, 0x9e, 0x6f, 0xd7, 0x69, 0x4e, 0xdc, 0x9f, 0xcd, 0x6f, 0x7f, + 0x97, 0xc5, 0xd1, 0x28, 0x21, 0x9b, 0x0f, 0xa8, 0x4a, 0x25, 0xa0, 0xbb, 0x65, 0x55, 0xac, 0x9b, + 0x5d, 0x38, 0x7c, 0x9d, 0x0b, 0x12, 0xe0, 0x97, 0xae, 0xc2, 0x24, 0x79, 0xa6, 0x29, 0x2b, 0x2a, + 0x49, 0xf7, 0x25, 0xb8, 0xfc, 0x37, 0x3f, 0xc0, 0x42, 0x75, 0x22, 0x60, 0x10, 0x91, 0x29, 0xd2, + 0x8b, 0x35, 0xec, 0xfb, 0xd8, 0xf5, 0x54, 0xcd, 0x6c, 0x27, 0x5e, 0x64, 0x0d, 0x23, 0xff, 0xc9, + 0x1f, 0xc4, 0x7b, 0x71, 0x91, 0x51, 0xce, 0x99, 0x66, 0xe9, 0x0a, 0xdc, 0xd5, 0xc6, 0x2b, 0x7a, + 0xe0, 0xf9, 0x29, 0xce, 0x73, 0xb2, 0xc5, 0x33, 0x08, 0xdb, 0x75, 0x10, 0xf0, 0xa0, 0x2f, 0x7b, + 0xe0, 0xf9, 0x57, 0x38, 0x4f, 0xc4, 0x69, 0x45, 0x97, 0x12, 0x8e, 0x97, 0x60, 0xfc, 0x3a, 0x76, + 0xb7, 0x6c, 0x8f, 0xaf, 0x1b, 0xf5, 0xc0, 0xee, 0xd3, 0x9c, 0xdd, 0x18, 0x27, 0xa4, 0x0b, 0x49, + 0x84, 0xd7, 0x93, 0x90, 0xd9, 0xd6, 0x74, 0xdc, 0x03, 0x8b, 0x97, 0x38, 0x8b, 0x41, 0x82, 0x4f, + 0x48, 0xe7, 0x60, 0xb8, 0x66, 0xf3, 0x51, 0xab, 0x3b, 0xf9, 0x67, 0x38, 0xf9, 0x90, 0xa0, 0xe1, + 0x2c, 0x1c, 0xdb, 0x69, 0x98, 0x64, 0x48, 0xeb, 0xce, 0xe2, 0xaf, 0x0a, 0x16, 0x82, 0x86, 0xb3, + 0xe8, 0xc3, 0xac, 0x9f, 0x15, 0x2c, 0xbc, 0x88, 0x3d, 0x9f, 0x82, 0x21, 0xdb, 0x32, 0xf7, 0x6c, + 0xab, 0x17, 0x21, 0x3e, 0xc7, 0x39, 0x00, 0x27, 0x21, 0x0c, 0xce, 0x43, 0xb6, 0xd7, 0x8e, 0xf8, + 0xeb, 0x3f, 0x10, 0xe1, 0x21, 0x7a, 0x60, 0x11, 0xc6, 0x44, 0x82, 0x32, 0x6c, 0xab, 0x07, 0x16, + 0x7f, 0x83, 0xb3, 0x18, 0x8d, 0x90, 0x71, 0x35, 0x7c, 0xec, 0xf9, 0x35, 0xdc, 0x0b, 0x93, 0x2f, + 0x0a, 0x35, 0x38, 0x09, 0x37, 0xe5, 0x16, 0xb6, 0xf4, 0x9d, 0xde, 0x38, 0xfc, 0xbc, 0x30, 0xa5, + 0xa0, 0x21, 0x2c, 0xe6, 0x61, 0xa4, 0xae, 0xb9, 0xde, 0x8e, 0x66, 0xf6, 0xd4, 0x1d, 0x7f, 0x93, + 0xf3, 0x18, 0x0e, 0x88, 0xb8, 0x45, 0x1a, 0x56, 0x3f, 0x6c, 0xbe, 0x24, 0x2c, 0x12, 0x21, 0xe3, + 0xa1, 0xe7, 0xf9, 0x74, 0x91, 0xad, 0x1f, 0x6e, 0xbf, 0x20, 0x42, 0x8f, 0xd1, 0xae, 0x44, 0x39, + 0x9e, 0x87, 0xac, 0x67, 0xdc, 0xec, 0x89, 0xcd, 0xdf, 0x12, 0x3d, 0x4d, 0x09, 0x08, 0xf1, 0xbb, + 0xe0, 0x68, 0xdb, 0x61, 0xa2, 0x07, 0x66, 0x7f, 0x9b, 0x33, 0x3b, 0xd2, 0x66, 0xa8, 0xe0, 0x29, + 0xa1, 0x5f, 0x96, 0x7f, 0x47, 0xa4, 0x04, 0xdc, 0xc4, 0x6b, 0x9d, 0xcc, 0x23, 0x3c, 0x6d, 0xbb, + 0x3f, 0xab, 0xfd, 0xa2, 0xb0, 0x1a, 0xa3, 0x8d, 0x59, 0x6d, 0x13, 0x8e, 0x70, 0x8e, 0xfd, 0xf5, + 0xeb, 0x2f, 0x89, 0xc4, 0xca, 0xa8, 0xaf, 0xc4, 0x7b, 0xf7, 0x3d, 0x50, 0x08, 0xcc, 0x29, 0x0a, + 0x56, 0x4f, 0xad, 0x6b, 0x4e, 0x0f, 0x9c, 0x7f, 0x99, 0x73, 0x16, 0x19, 0x3f, 0xa8, 0x78, 0xbd, + 0x15, 0xcd, 0x21, 0xcc, 0x9f, 0x85, 0xbc, 0x60, 0xde, 0xb0, 0x5c, 0xac, 0xdb, 0x35, 0xcb, 0xb8, + 0x89, 0xab, 0x3d, 0xb0, 0xfe, 0xbb, 0x4d, 0x5d, 0x75, 0x25, 0x42, 0x4e, 0x38, 0x2f, 0x41, 0x2e, + 0xa8, 0x55, 0x54, 0xa3, 0xee, 0xd8, 0xae, 0xdf, 0x85, 0xe3, 0x97, 0x45, 0x4f, 0x05, 0x74, 0x4b, + 0x94, 0xac, 0x54, 0x01, 0xb6, 0xf3, 0xdc, 0xab, 0x4b, 0xfe, 0x0a, 0x67, 0x34, 0x12, 0x52, 0xf1, + 0xc4, 0xa1, 0xdb, 0x75, 0x47, 0x73, 0x7b, 0xc9, 0x7f, 0x7f, 0x4f, 0x24, 0x0e, 0x4e, 0xc2, 0x13, + 0x87, 0xbf, 0xe7, 0x60, 0x32, 0xda, 0xf7, 0xc0, 0xe1, 0x57, 0x45, 0xe2, 0x10, 0x34, 0x9c, 0x85, + 0x28, 0x18, 0x7a, 0x60, 0xf1, 0xf7, 0x05, 0x0b, 0x41, 0x43, 0x58, 0x3c, 0x1d, 0x0e, 0xb4, 0x2e, + 0xae, 0x19, 0x9e, 0xef, 0xb2, 0x32, 0x79, 0x7f, 0x56, 0xff, 0xe0, 0x07, 0xf1, 0x22, 0x4c, 0x89, + 0x90, 0x92, 0x4c, 0xc4, 0x97, 0x5d, 0xe9, 0x2c, 0xaa, 0xbb, 0x60, 0xbf, 0x26, 0x32, 0x51, 0x84, + 0x8c, 0xc8, 0x16, 0xa9, 0x10, 0x89, 0xd9, 0x75, 0x32, 0x77, 0xe8, 0x81, 0xdd, 0x3f, 0x6c, 0x12, + 0x6e, 0x43, 0xd0, 0x12, 0x9e, 0x91, 0xfa, 0xa7, 0x61, 0x5d, 0xc3, 0x7b, 0x3d, 0x79, 0xe7, 0xaf, + 0x37, 0xd5, 0x3f, 0x57, 0x18, 0x25, 0xcb, 0x21, 0x63, 0x4d, 0xf5, 0x14, 0xea, 0x76, 0xce, 0x28, + 0xff, 0x93, 0xaf, 0x70, 0x7d, 0xe3, 0xe5, 0x54, 0x69, 0x99, 0x38, 0x79, 0xbc, 0xe8, 0xe9, 0xce, + 0xec, 0x03, 0xaf, 0x04, 0x7e, 0x1e, 0xab, 0x79, 0x4a, 0x17, 0x60, 0x24, 0x56, 0xf0, 0x74, 0x67, + 0xf5, 0x41, 0xce, 0x6a, 0x38, 0x5a, 0xef, 0x94, 0x9e, 0x80, 0x14, 0x29, 0x5e, 0xba, 0x93, 0x7f, + 0x88, 0x93, 0x53, 0xf4, 0xd2, 0xdb, 0x21, 0x23, 0x8a, 0x96, 0xee, 0xa4, 0x1f, 0xe6, 0xa4, 0x01, + 0x09, 0x21, 0x17, 0x05, 0x4b, 0x77, 0xf2, 0x3f, 0x2b, 0xc8, 0x05, 0x09, 0x21, 0xef, 0xdd, 0x84, + 0x5f, 0xf9, 0x73, 0x29, 0x3e, 0xe8, 0x08, 0xdb, 0x9d, 0x87, 0x41, 0x5e, 0xa9, 0x74, 0xa7, 0xfe, + 0x08, 0x6f, 0x5c, 0x50, 0x94, 0xce, 0x42, 0xba, 0x47, 0x83, 0xff, 0x0c, 0x27, 0x65, 0xf8, 0xa5, + 0x79, 0x18, 0x8a, 0x54, 0x27, 0xdd, 0xc9, 0xff, 0x02, 0x27, 0x8f, 0x52, 0x11, 0xd1, 0x79, 0x75, + 0xd2, 0x9d, 0xc1, 0x47, 0x85, 0xe8, 0x9c, 0x82, 0x98, 0x4d, 0x14, 0x26, 0xdd, 0xa9, 0x3f, 0x26, + 0xac, 0x2e, 0x48, 0x4a, 0x4f, 0x41, 0x36, 0x18, 0x6c, 0xba, 0xd3, 0x7f, 0x9c, 0xd3, 0x87, 0x34, + 0xc4, 0x02, 0x91, 0xc1, 0xae, 0x3b, 0x8b, 0xbf, 0x28, 0x2c, 0x10, 0xa1, 0x22, 0x61, 0xd4, 0x5c, + 0xc0, 0x74, 0xe7, 0xf4, 0xb3, 0x22, 0x8c, 0x9a, 0xea, 0x17, 0xd2, 0x9b, 0x34, 0xe7, 0x77, 0x67, + 0xf1, 0x73, 0xa2, 0x37, 0x29, 0x3e, 0x11, 0xa3, 0xb9, 0x22, 0xe8, 0xce, 0xe3, 0x2f, 0x0b, 0x31, + 0x9a, 0x0a, 0x82, 0xd2, 0x3a, 0xa0, 0xd6, 0x6a, 0xa0, 0x3b, 0xbf, 0x4f, 0x70, 0x7e, 0xe3, 0x2d, + 0xc5, 0x40, 0xe9, 0x19, 0x38, 0xd2, 0xbe, 0x12, 0xe8, 0xce, 0xf5, 0x93, 0xaf, 0x34, 0xcd, 0xdd, + 0xa2, 0x85, 0x40, 0x69, 0x33, 0x1c, 0x52, 0xa2, 0x55, 0x40, 0x77, 0xb6, 0x9f, 0x7a, 0x25, 0x9e, + 0xb8, 0xa3, 0x45, 0x40, 0x69, 0x0e, 0x20, 0x1c, 0x80, 0xbb, 0xf3, 0xfa, 0x34, 0xe7, 0x15, 0x21, + 0x22, 0xa1, 0xc1, 0xc7, 0xdf, 0xee, 0xf4, 0x2f, 0x89, 0xd0, 0xe0, 0x14, 0x24, 0x34, 0xc4, 0xd0, + 0xdb, 0x9d, 0xfa, 0x33, 0x22, 0x34, 0x04, 0x09, 0xf1, 0xec, 0xc8, 0xe8, 0xd6, 0x9d, 0xc3, 0xe7, + 0x84, 0x67, 0x47, 0xa8, 0x4a, 0xab, 0x30, 0xde, 0x32, 0x20, 0x76, 0x67, 0xf5, 0x79, 0xce, 0x2a, + 0xd7, 0x3c, 0x1e, 0x46, 0x07, 0x2f, 0x3e, 0x18, 0x76, 0xe7, 0xf6, 0x85, 0xa6, 0xc1, 0x8b, 0x8f, + 0x85, 0xa5, 0xf3, 0x90, 0xb1, 0x1a, 0xa6, 0x49, 0x82, 0x07, 0xed, 0x7f, 0x36, 0x30, 0xff, 0x87, + 0xaf, 0x72, 0xeb, 0x08, 0x82, 0xd2, 0x13, 0x90, 0xc6, 0xf5, 0x2d, 0x5c, 0xed, 0x46, 0xf9, 0xfd, + 0x57, 0x45, 0xc2, 0x24, 0xd8, 0xa5, 0xa7, 0x00, 0xd8, 0xd2, 0x08, 0xdd, 0x1e, 0xec, 0x42, 0xfb, + 0x5f, 0x5e, 0xe5, 0x87, 0x71, 0x42, 0x92, 0x90, 0x01, 0x3b, 0xda, 0xb3, 0x3f, 0x83, 0x1f, 0xc4, + 0x19, 0xd0, 0x1e, 0x79, 0x12, 0x06, 0x9f, 0xf3, 0x6c, 0xcb, 0xd7, 0x6a, 0xdd, 0xa8, 0xff, 0x2b, + 0xa7, 0x16, 0xf8, 0xc4, 0x60, 0x75, 0xdb, 0xc5, 0xbe, 0x56, 0xf3, 0xba, 0xd1, 0xfe, 0x37, 0x4e, + 0x1b, 0x10, 0x10, 0x62, 0x5d, 0xf3, 0xfc, 0x5e, 0xf4, 0xfe, 0x23, 0x41, 0x2c, 0x08, 0x88, 0xd0, + 0xe4, 0xf9, 0x1a, 0xde, 0xeb, 0x46, 0xfb, 0xc7, 0x42, 0x68, 0x8e, 0x5f, 0x7a, 0x3b, 0x64, 0xc9, + 0x23, 0x3b, 0x61, 0xd7, 0x85, 0xf8, 0xbf, 0x73, 0xe2, 0x90, 0x82, 0xb4, 0xec, 0xf9, 0x55, 0xdf, + 0xe8, 0x6e, 0xec, 0xdb, 0xbc, 0xa7, 0x05, 0x7e, 0x69, 0x0e, 0x86, 0x3c, 0xbf, 0x5a, 0x6d, 0xf0, + 0xfa, 0xb4, 0x0b, 0xf9, 0xff, 0x78, 0x35, 0x58, 0xb2, 0x08, 0x68, 0x48, 0x6f, 0xdf, 0xb8, 0xe6, + 0x3b, 0x36, 0xdd, 0x02, 0xe9, 0xc6, 0xe1, 0x15, 0xce, 0x21, 0x42, 0x52, 0x9a, 0x87, 0x61, 0xa2, + 0x8b, 0x8b, 0x1d, 0x4c, 0xf7, 0xab, 0xba, 0xb0, 0xf8, 0x9f, 0xdc, 0x00, 0x31, 0xa2, 0xf2, 0x4f, + 0x74, 0xba, 0x9f, 0xd3, 0x7e, 0xd9, 0x18, 0x16, 0xed, 0x45, 0x9b, 0x2d, 0x18, 0xbf, 0x5b, 0x8e, + 0x2d, 0x17, 0xd7, 0xec, 0x70, 0xb5, 0x36, 0x98, 0xe4, 0xc0, 0x6f, 0xa6, 0x49, 0xd5, 0x4c, 0xd7, + 0x72, 0x35, 0xc7, 0x98, 0xdd, 0xf1, 0x7d, 0x87, 0xaf, 0xf6, 0x02, 0x67, 0xad, 0x39, 0x86, 0xbc, + 0x07, 0xa9, 0x8b, 0xbe, 0xef, 0xa0, 0x93, 0x90, 0x76, 0x1b, 0x26, 0xf6, 0xf8, 0x2a, 0xfb, 0x64, + 0x31, 0xc4, 0x29, 0x12, 0x04, 0xa5, 0x61, 0x62, 0x85, 0xa1, 0xa0, 0x0a, 0x4c, 0x6f, 0x37, 0x4c, + 0x73, 0x4f, 0xad, 0x62, 0x7a, 0x09, 0x23, 0x38, 0xc6, 0x88, 0x77, 0x1d, 0x4d, 0x6c, 0x86, 0x10, + 0x93, 0x1d, 0xa7, 0x68, 0x0b, 0x14, 0x4b, 0x1c, 0x61, 0xac, 0x08, 0x1c, 0xf9, 0xf7, 0x13, 0x90, + 0x11, 0xac, 0x51, 0x01, 0x32, 0x1e, 0x36, 0xb1, 0xee, 0xdb, 0x2e, 0x3f, 0x5b, 0x16, 0xbc, 0x23, + 0x04, 0xc9, 0x1a, 0xbf, 0x55, 0x95, 0xbd, 0x78, 0x48, 0x21, 0x2f, 0x04, 0xe6, 0x34, 0xd8, 0x95, + 0x2a, 0x0a, 0x73, 0x1a, 0x3e, 0x9a, 0x84, 0x94, 0x63, 0x7b, 0x3e, 0xdb, 0xa0, 0xb8, 0x78, 0x48, + 0xa1, 0x6f, 0x28, 0x0f, 0x03, 0x55, 0x6c, 0x62, 0x9f, 0xed, 0x30, 0x11, 0x38, 0x7f, 0x47, 0x47, + 0x20, 0xed, 0x68, 0xbe, 0xbe, 0xc3, 0x8e, 0x58, 0x5f, 0x3c, 0xa4, 0xb0, 0x57, 0x84, 0x20, 0xb5, + 0x65, 0x57, 0xf7, 0xf8, 0xe1, 0x69, 0xfa, 0x8c, 0xce, 0xc2, 0x00, 0x8b, 0xf6, 0xe6, 0x53, 0xcf, + 0xc4, 0x40, 0x6c, 0x59, 0x95, 0xe8, 0xb2, 0xae, 0x91, 0x0a, 0xde, 0x22, 0x8d, 0x30, 0x74, 0x54, + 0x81, 0x09, 0xad, 0x5a, 0x35, 0xd8, 0xd9, 0x66, 0x75, 0xcb, 0xb0, 0xaa, 0x86, 0x55, 0xf3, 0xe8, + 0x2d, 0xa1, 0x4e, 0x66, 0x46, 0x21, 0x41, 0x99, 0xe3, 0xf3, 0xd3, 0xa2, 0xf4, 0x26, 0x98, 0x4a, + 0x85, 0x63, 0x77, 0x56, 0x86, 0x05, 0xb0, 0x6c, 0x57, 0xf7, 0xca, 0x59, 0x18, 0x74, 0x98, 0x00, + 0xf2, 0x79, 0x18, 0x6f, 0x91, 0x8a, 0x28, 0x76, 0xcd, 0xb0, 0xaa, 0xe2, 0x18, 0x23, 0x79, 0x26, + 0x30, 0xba, 0x0d, 0xc2, 0xf6, 0x39, 0xe8, 0x73, 0xf9, 0xa7, 0xa4, 0x8e, 0xae, 0x39, 0x1a, 0x71, + 0x4d, 0xcd, 0x31, 0xca, 0x59, 0xca, 0x9f, 0xb8, 0xd5, 0xba, 0xf4, 0xee, 0x39, 0xfe, 0x81, 0xed, + 0x60, 0x14, 0x6d, 0xb7, 0x36, 0x5b, 0xc3, 0x96, 0xd8, 0x6d, 0x20, 0x9f, 0x34, 0xc7, 0xf0, 0xa8, + 0x3b, 0x86, 0xdb, 0x32, 0xde, 0xf9, 0xc8, 0x33, 0xdd, 0xc8, 0x48, 0x2d, 0xce, 0xad, 0x2f, 0x05, + 0x57, 0xcf, 0xbe, 0x9a, 0x80, 0xe3, 0x11, 0x3f, 0x8e, 0x20, 0xb7, 0xba, 0x73, 0xa1, 0xbd, 0xc7, + 0xf7, 0xb0, 0xa9, 0x71, 0x19, 0x52, 0x04, 0x1f, 0x75, 0x39, 0x84, 0x99, 0xff, 0xa5, 0x7f, 0xf6, + 0x8f, 0x64, 0xea, 0x00, 0xed, 0xbb, 0x8e, 0x32, 0x29, 0x7f, 0xb8, 0x77, 0xfb, 0xe5, 0xc2, 0x1d, + 0x29, 0xef, 0xce, 0x99, 0xb1, 0xd9, 0x86, 0x1f, 0x4b, 0xc0, 0x74, 0xb3, 0x09, 0x48, 0x32, 0xf5, + 0x7c, 0xad, 0xee, 0x74, 0xba, 0xbd, 0x77, 0x1e, 0xb2, 0x9b, 0x02, 0x07, 0xe5, 0x61, 0xd0, 0xc3, + 0xba, 0x6d, 0x55, 0x3d, 0xea, 0x3d, 0x49, 0x45, 0xbc, 0xa2, 0x49, 0x48, 0x5b, 0x9a, 0x65, 0x7b, + 0xfc, 0xcc, 0x30, 0x7b, 0x29, 0xff, 0x25, 0xa9, 0xbf, 0xec, 0x36, 0x1a, 0x34, 0x25, 0xac, 0xf0, + 0xd0, 0x7e, 0x5b, 0x62, 0xec, 0x8e, 0x62, 0xa0, 0x42, 0x64, 0xff, 0x6b, 0xaa, 0x79, 0xff, 0xeb, + 0x19, 0x6c, 0x9a, 0x97, 0x2d, 0xfb, 0x86, 0xb5, 0x49, 0x68, 0x02, 0x93, 0xfc, 0xae, 0x04, 0x33, + 0xf4, 0xd6, 0x84, 0x5b, 0x37, 0x2c, 0x7f, 0xd6, 0x34, 0xb6, 0xbc, 0xd9, 0x2d, 0xc3, 0xf7, 0xd8, + 0xf5, 0x47, 0x6e, 0x93, 0xc9, 0x10, 0xa3, 0x48, 0x30, 0x8a, 0x04, 0x43, 0x3e, 0x0d, 0x99, 0xb2, + 0xe1, 0xcf, 0xb9, 0xae, 0xb6, 0x47, 0x73, 0x85, 0xe1, 0x0b, 0xa3, 0xd0, 0x67, 0x62, 0x11, 0x6c, + 0xe2, 0xba, 0x47, 0x77, 0x5e, 0x53, 0x0a, 0x7b, 0x29, 0x5f, 0xe9, 0x78, 0x1d, 0xf3, 0x7c, 0x44, + 0xd3, 0x88, 0x48, 0x91, 0x47, 0xd6, 0xf7, 0xed, 0xc4, 0x0d, 0xf4, 0xf9, 0x52, 0x0a, 0xee, 0x8e, + 0x20, 0xe8, 0xee, 0x9e, 0xe3, 0xd3, 0x71, 0xc1, 0xde, 0xe6, 0xca, 0x8c, 0x47, 0x94, 0x61, 0x9f, + 0x0b, 0x6d, 0x77, 0x03, 0xe5, 0x6d, 0x48, 0xaf, 0x13, 0xba, 0xf0, 0x5e, 0x29, 0xd3, 0x8e, 0xbd, + 0x10, 0x28, 0xbb, 0x39, 0x92, 0x60, 0x50, 0x43, 0x5c, 0x1a, 0x31, 0xb1, 0xb6, 0xcd, 0x0e, 0xe0, + 0x26, 0xe9, 0x06, 0x7c, 0x86, 0x00, 0xe8, 0x59, 0xdb, 0x49, 0x48, 0x6b, 0x0d, 0xb6, 0x77, 0x9c, + 0x3c, 0x31, 0xac, 0xb0, 0x17, 0xf9, 0x32, 0x0c, 0xf2, 0xfd, 0xaa, 0x36, 0xb7, 0x69, 0x8b, 0x90, + 0xa6, 0xc2, 0xf3, 0x9b, 0x05, 0xf9, 0x62, 0x8b, 0xf4, 0x45, 0x2a, 0xa4, 0xc2, 0xd0, 0xe4, 0x4b, + 0x90, 0x59, 0xb0, 0xeb, 0x86, 0x65, 0xc7, 0xb9, 0x65, 0x19, 0x37, 0x2a, 0x33, 0x19, 0x30, 0x58, + 0x9a, 0x63, 0x2f, 0xf4, 0xc6, 0x2e, 0x3d, 0x90, 0xcd, 0xf7, 0xbf, 0xf9, 0x9b, 0x3c, 0x0f, 0x83, + 0x94, 0xf7, 0x9a, 0x43, 0xfa, 0x37, 0x38, 0x0d, 0x97, 0xe5, 0xd7, 0x73, 0x38, 0xfb, 0x44, 0x28, + 0x2c, 0x82, 0x54, 0x55, 0xf3, 0x35, 0xae, 0x37, 0x7d, 0x96, 0xdf, 0x01, 0x19, 0xce, 0xc4, 0x43, + 0xa7, 0x20, 0x69, 0x3b, 0x62, 0x6c, 0x2d, 0x74, 0x52, 0x65, 0xcd, 0x29, 0xa7, 0xbe, 0x7e, 0x6b, + 0xfa, 0x90, 0x42, 0x90, 0xcb, 0x4a, 0x47, 0x7f, 0x39, 0xd7, 0xbf, 0xbf, 0xb0, 0x66, 0x02, 0x67, + 0xf9, 0x5c, 0x02, 0xa6, 0x22, 0x5f, 0xaf, 0x63, 0x97, 0x8c, 0xc8, 0x31, 0xd7, 0x47, 0x11, 0x21, + 0xf9, 0xf7, 0x0e, 0xee, 0xf2, 0x76, 0x48, 0xce, 0x39, 0x0e, 0x19, 0xc1, 0xd9, 0x4e, 0xb5, 0xcd, + 0xfc, 0x25, 0xa5, 0x04, 0xef, 0x74, 0x74, 0xb7, 0xb7, 0xfd, 0x1b, 0x9a, 0x1b, 0xdc, 0x59, 0x12, + 0xef, 0xf2, 0x93, 0x90, 0x9d, 0x27, 0x23, 0x98, 0xe5, 0x35, 0x68, 0xe8, 0x6c, 0x99, 0xb6, 0x7e, + 0x8d, 0x73, 0x60, 0x2f, 0xc4, 0xe0, 0x9a, 0xe3, 0xf0, 0xdb, 0xcd, 0xe4, 0xb1, 0x94, 0xfa, 0xde, + 0x67, 0xa7, 0xa5, 0xf2, 0x46, 0x47, 0x13, 0x3d, 0xd9, 0xbf, 0x89, 0xb8, 0x92, 0x81, 0x8d, 0x7e, + 0xfd, 0x28, 0x1c, 0x8f, 0x92, 0xb2, 0x8c, 0x13, 0xb1, 0x50, 0x2e, 0x62, 0x21, 0x0a, 0x6f, 0x6f, + 0x9f, 0x42, 0xb7, 0xcc, 0x5b, 0xe8, 0x9a, 0x87, 0x0a, 0xfb, 0x47, 0x76, 0xa1, 0x4b, 0x5f, 0xca, + 0x4f, 0xc2, 0xc8, 0xba, 0xe6, 0xfa, 0x1b, 0xd8, 0xbf, 0x88, 0xb5, 0x2a, 0x76, 0xe3, 0x81, 0x3d, + 0x22, 0x02, 0x1b, 0x41, 0x8a, 0x46, 0x2f, 0x73, 0x6c, 0xfa, 0x2c, 0xef, 0x40, 0x8a, 0x9e, 0x76, + 0x09, 0x82, 0x9e, 0x53, 0xb0, 0xa0, 0x27, 0xdd, 0xb5, 0xe7, 0x63, 0x8f, 0x93, 0xb0, 0x17, 0x74, + 0x5a, 0x84, 0x6e, 0x72, 0xff, 0xd0, 0xe5, 0xde, 0xce, 0x03, 0xd8, 0x84, 0xc1, 0x32, 0xe9, 0xed, + 0xa5, 0x85, 0x40, 0x10, 0x29, 0x14, 0x04, 0xad, 0xc0, 0x98, 0xa3, 0xb9, 0x3e, 0x3d, 0xe6, 0xbb, + 0x43, 0xb5, 0xe0, 0x99, 0x61, 0xba, 0xd8, 0xdc, 0x0f, 0xc5, 0x98, 0xb2, 0xbc, 0x95, 0x11, 0x27, + 0x0a, 0x94, 0xff, 0x53, 0x0a, 0x06, 0xb8, 0x31, 0xde, 0x0e, 0x83, 0xdc, 0x68, 0xb4, 0x41, 0x52, + 0xdb, 0xb5, 0xfa, 0x7e, 0x31, 0xf0, 0x51, 0xce, 0x4f, 0xd0, 0xa0, 0xfb, 0x21, 0xa3, 0xef, 0x68, + 0x86, 0xa5, 0x1a, 0xec, 0xbc, 0x6b, 0xb6, 0x3c, 0xf4, 0xf2, 0xad, 0xe9, 0xc1, 0x79, 0x02, 0x5b, + 0x5a, 0x50, 0x06, 0xe9, 0xc7, 0xa5, 0x2a, 0x49, 0x36, 0x3b, 0xd8, 0xa8, 0xed, 0xb0, 0x64, 0x93, + 0x54, 0xf8, 0x1b, 0x3a, 0x07, 0x29, 0xe2, 0x10, 0xfc, 0x12, 0x48, 0xa1, 0xa5, 0xfe, 0x08, 0x06, + 0xc6, 0x72, 0x86, 0x34, 0xfc, 0xb1, 0x6f, 0x4f, 0x4b, 0x0a, 0xa5, 0x40, 0xf3, 0x30, 0x62, 0x6a, + 0x9e, 0xaf, 0xd2, 0x20, 0x21, 0xcd, 0xa7, 0x29, 0x8b, 0xa3, 0xad, 0x06, 0xe1, 0x86, 0xe5, 0xa2, + 0x0f, 0x11, 0x2a, 0x06, 0xaa, 0xa2, 0x13, 0x90, 0xa3, 0x4c, 0x74, 0xbb, 0x5e, 0x37, 0x7c, 0x96, + 0xbe, 0x07, 0xa8, 0xdd, 0x47, 0x09, 0x7c, 0x9e, 0x82, 0x69, 0x12, 0x3f, 0x06, 0x59, 0x7a, 0xec, + 0x9c, 0xa2, 0xb0, 0x23, 0x56, 0x19, 0x02, 0xa0, 0x1f, 0x1f, 0x80, 0xb1, 0xeb, 0x9a, 0x69, 0x54, + 0x35, 0xdf, 0x76, 0x3d, 0x86, 0x92, 0x61, 0x5c, 0x42, 0x30, 0x45, 0x7c, 0x14, 0x26, 0xe9, 0xcf, + 0x18, 0x34, 0x63, 0x67, 0x29, 0x36, 0x22, 0xdf, 0xae, 0xc6, 0x29, 0xde, 0x46, 0x8a, 0x26, 0x6e, + 0x7c, 0x86, 0x0b, 0x14, 0x77, 0x24, 0x80, 0x52, 0xb4, 0xa3, 0x90, 0xd1, 0x1c, 0x87, 0x21, 0x0c, + 0xb1, 0xdf, 0x47, 0xd0, 0x1c, 0x87, 0x7e, 0x3a, 0x09, 0xe3, 0x54, 0x47, 0x17, 0x7b, 0x0d, 0xd3, + 0xe7, 0x4c, 0x86, 0x29, 0xce, 0x18, 0xf9, 0xa0, 0x30, 0x38, 0xc5, 0xbd, 0x17, 0x46, 0xf0, 0x75, + 0xa3, 0x8a, 0x2d, 0x1d, 0x33, 0xbc, 0x11, 0x8a, 0x37, 0x2c, 0x80, 0x14, 0xe9, 0x41, 0xc8, 0x39, + 0xae, 0xed, 0xd8, 0x1e, 0x76, 0x55, 0xad, 0x5a, 0x75, 0xb1, 0xe7, 0xe5, 0x47, 0x19, 0x3f, 0x01, + 0x9f, 0x63, 0x60, 0xf9, 0x61, 0x48, 0x2d, 0x68, 0xbe, 0x46, 0x72, 0x98, 0xbf, 0xcb, 0x86, 0x80, + 0x61, 0x85, 0x3c, 0xb6, 0x0d, 0xb7, 0xef, 0x25, 0x20, 0x75, 0xd5, 0xf6, 0x31, 0x7a, 0x3c, 0x32, + 0xee, 0x8c, 0xb6, 0xf3, 0xf1, 0x0d, 0xa3, 0x66, 0xe1, 0xea, 0x8a, 0x57, 0x8b, 0xdc, 0x1b, 0x0d, + 0x5d, 0x2c, 0x11, 0x73, 0xb1, 0x49, 0x48, 0xbb, 0x76, 0xc3, 0xaa, 0x8a, 0x13, 0x4b, 0xf4, 0x05, + 0x55, 0x20, 0x13, 0x78, 0x4e, 0xaa, 0x9b, 0xe7, 0x8c, 0x11, 0xcf, 0x21, 0x7e, 0xcd, 0x01, 0xca, + 0xe0, 0x16, 0x77, 0xa0, 0x32, 0x64, 0x83, 0x84, 0xc6, 0x3d, 0xb0, 0x37, 0x27, 0x0e, 0xc9, 0xd0, + 0x43, 0x30, 0x1e, 0xf8, 0x43, 0x60, 0x50, 0xe6, 0x85, 0xb9, 0xe0, 0x03, 0xb7, 0x68, 0xcc, 0xd5, + 0xf8, 0x1d, 0xd6, 0x41, 0xaa, 0x57, 0xe8, 0x6a, 0xec, 0x1e, 0xeb, 0x71, 0xc8, 0x7a, 0x46, 0xcd, + 0xd2, 0xfc, 0x86, 0x8b, 0xb9, 0x37, 0x86, 0x00, 0xf9, 0xe3, 0x09, 0x18, 0x60, 0xde, 0x1d, 0xb1, + 0x9b, 0xd4, 0xde, 0x6e, 0x89, 0x4e, 0x76, 0x4b, 0x1e, 0xdc, 0x6e, 0x73, 0x00, 0x81, 0x30, 0x1e, + 0xbf, 0x5a, 0x78, 0xac, 0x95, 0x11, 0x13, 0x71, 0xc3, 0xa8, 0xf1, 0xe0, 0x8d, 0x10, 0x05, 0x1e, + 0x94, 0x8e, 0xe4, 0xc9, 0xf3, 0x90, 0xdd, 0x32, 0x7c, 0x55, 0x23, 0xd5, 0x29, 0x35, 0xe1, 0xd0, + 0xa9, 0xa9, 0x62, 0xbb, 0x32, 0xb6, 0x28, 0x6a, 0x58, 0x25, 0xb3, 0xc5, 0x9f, 0xe4, 0xff, 0x20, + 0x91, 0xc1, 0x98, 0x37, 0x88, 0xe6, 0x60, 0x44, 0x28, 0xaa, 0x6e, 0x9b, 0x5a, 0x8d, 0x3b, 0xe3, + 0xdd, 0x1d, 0xb5, 0xbd, 0x60, 0x6a, 0x35, 0x65, 0x88, 0x2b, 0x48, 0x5e, 0xda, 0x77, 0x6c, 0xa2, + 0x43, 0xc7, 0xc6, 0x3c, 0x29, 0x79, 0x30, 0x4f, 0x8a, 0xf5, 0x79, 0xaa, 0xb9, 0xcf, 0xbf, 0x9c, + 0xa0, 0x45, 0x99, 0x63, 0x7b, 0x9a, 0xf9, 0x46, 0x84, 0xd8, 0x31, 0xc8, 0x3a, 0xb6, 0xa9, 0xb2, + 0x2f, 0xec, 0x68, 0x60, 0xc6, 0xb1, 0x4d, 0xa5, 0xc5, 0x8f, 0xd2, 0x77, 0x28, 0xfe, 0x06, 0xee, + 0x80, 0xd5, 0x06, 0x9b, 0xad, 0xe6, 0xc2, 0x30, 0x33, 0x05, 0x1f, 0x30, 0x1f, 0x25, 0x36, 0xa0, + 0x23, 0xb0, 0xd4, 0x3a, 0xc0, 0x33, 0xb1, 0x19, 0xa6, 0xc2, 0xf1, 0x08, 0x05, 0x1b, 0x5f, 0xda, + 0x55, 0xf3, 0x51, 0x3f, 0x57, 0x38, 0x9e, 0xfc, 0x4f, 0x25, 0xc8, 0x52, 0x55, 0x57, 0xb0, 0xaf, + 0xc5, 0x4c, 0x25, 0x1d, 0xdc, 0x54, 0x77, 0x03, 0x30, 0x36, 0x9e, 0x71, 0x13, 0xf3, 0x0e, 0xcc, + 0x52, 0xc8, 0x86, 0x71, 0x13, 0xa3, 0x33, 0x81, 0x5e, 0xc9, 0xfd, 0xf5, 0xe2, 0xa1, 0x28, 0xb4, + 0xbb, 0x0b, 0x06, 0xe9, 0x4f, 0x68, 0xec, 0xb2, 0xb3, 0xb1, 0x49, 0x7a, 0x6f, 0x76, 0x73, 0xd7, + 0x93, 0x9f, 0x83, 0xc1, 0xcd, 0x5d, 0x36, 0x95, 0x3a, 0x06, 0x59, 0xd7, 0xb6, 0xf9, 0xf8, 0xca, + 0xea, 0x9a, 0x0c, 0x01, 0xd0, 0xe1, 0x44, 0x4c, 0x1f, 0x12, 0xe1, 0xf4, 0x21, 0x9c, 0xff, 0x24, + 0x7b, 0x9a, 0xff, 0x9c, 0xfc, 0xb7, 0x12, 0x0c, 0x45, 0xc2, 0x10, 0x3d, 0x06, 0x87, 0xcb, 0xcb, + 0x6b, 0xf3, 0x97, 0xd5, 0xa5, 0x05, 0xf5, 0xc2, 0xf2, 0xdc, 0x62, 0x78, 0xc6, 0xbc, 0x70, 0xe4, + 0xc5, 0x97, 0x66, 0x50, 0x04, 0xf7, 0x8a, 0x75, 0x8d, 0xcc, 0x8f, 0xd1, 0x2c, 0x4c, 0xc6, 0x49, + 0xe6, 0xca, 0x1b, 0x95, 0xd5, 0xcd, 0x9c, 0x54, 0x38, 0xfc, 0xe2, 0x4b, 0x33, 0xe3, 0x11, 0x8a, + 0xb9, 0x2d, 0x0f, 0x5b, 0x7e, 0x2b, 0xc1, 0xfc, 0xda, 0xca, 0xca, 0xd2, 0x66, 0x2e, 0xd1, 0x42, + 0xc0, 0x13, 0xed, 0x83, 0x30, 0x1e, 0x27, 0x58, 0x5d, 0x5a, 0xce, 0x25, 0x0b, 0xe8, 0xc5, 0x97, + 0x66, 0x46, 0x23, 0xd8, 0xab, 0x86, 0x59, 0xc8, 0xfc, 0xf4, 0x17, 0xa6, 0x0e, 0xfd, 0xfc, 0x5f, + 0x9b, 0x92, 0x88, 0x66, 0x23, 0xb1, 0x50, 0x44, 0x0f, 0xc3, 0x5d, 0x1b, 0x4b, 0x8b, 0xab, 0x95, + 0x05, 0x75, 0x65, 0x63, 0x51, 0x65, 0x77, 0xeb, 0x03, 0xed, 0xc6, 0x5e, 0x7c, 0x69, 0x66, 0x88, + 0xab, 0xd4, 0x09, 0x7b, 0x5d, 0xa9, 0x5c, 0x5d, 0xdb, 0xac, 0xe4, 0x24, 0x86, 0xbd, 0xee, 0xe2, + 0xeb, 0xb6, 0xcf, 0x7e, 0x63, 0xe7, 0x51, 0x38, 0xda, 0x06, 0x3b, 0x50, 0x6c, 0xfc, 0xc5, 0x97, + 0x66, 0x46, 0xd6, 0x5d, 0xcc, 0xdc, 0x94, 0x52, 0x14, 0x21, 0xdf, 0x4a, 0xb1, 0xb6, 0xbe, 0xb6, + 0x31, 0xb7, 0x9c, 0x9b, 0x29, 0xe4, 0x5e, 0x7c, 0x69, 0x66, 0x58, 0xe4, 0x1c, 0x82, 0x1f, 0x6a, + 0x56, 0x7e, 0xba, 0xe3, 0xfc, 0xe5, 0x6c, 0xff, 0xf3, 0x17, 0x3f, 0xb6, 0xbc, 0xf1, 0xe7, 0x13, + 0x30, 0xd5, 0xb2, 0xe8, 0xc5, 0xd7, 0xbf, 0x3b, 0x2d, 0xf8, 0x94, 0x20, 0xb3, 0x20, 0x96, 0xd5, + 0xfb, 0x5d, 0xef, 0xf9, 0xb9, 0x3e, 0xd7, 0x7b, 0x46, 0x44, 0x4b, 0x62, 0xb9, 0xe7, 0x64, 0xf7, + 0xe5, 0x1e, 0x21, 0xff, 0x01, 0x56, 0x7b, 0x3e, 0x98, 0x84, 0xa9, 0xe8, 0xcf, 0x80, 0x89, 0x1f, + 0x00, 0xd3, 0x6d, 0x43, 0x98, 0x63, 0x22, 0xfa, 0xd3, 0x5f, 0xfc, 0x7b, 0x87, 0x19, 0xef, 0x22, + 0xa4, 0xe6, 0x6d, 0xc3, 0x22, 0xa6, 0xa8, 0x62, 0xcb, 0xae, 0xf3, 0xd5, 0x01, 0xf6, 0x82, 0xee, + 0x85, 0x01, 0xad, 0x6e, 0x37, 0x2c, 0x5f, 0x4c, 0x07, 0x48, 0xb2, 0xf8, 0xfd, 0x5b, 0xd3, 0xc9, + 0x25, 0xcb, 0x57, 0xf8, 0x27, 0x36, 0x81, 0x95, 0x2f, 0xc1, 0xe0, 0x02, 0xd6, 0x0f, 0xc2, 0x6b, + 0x01, 0xeb, 0x4d, 0xbc, 0x1e, 0x84, 0xcc, 0x92, 0xe5, 0xb3, 0xfb, 0xea, 0x77, 0x43, 0xd2, 0xb0, + 0x58, 0x35, 0xd3, 0xd4, 0x3e, 0x81, 0x13, 0xd4, 0x05, 0xac, 0x07, 0xa8, 0x55, 0xac, 0x37, 0xa3, + 0x12, 0xf6, 0x04, 0x5e, 0x5e, 0xf8, 0xbd, 0xff, 0x38, 0x75, 0xe8, 0x85, 0x97, 0xa7, 0x0e, 0x75, + 0x74, 0x55, 0xb9, 0xfb, 0x8f, 0x89, 0x05, 0xdd, 0xf0, 0xa1, 0xc7, 0xe0, 0x3e, 0x8e, 0xe3, 0xf9, + 0xda, 0x35, 0xc3, 0xaa, 0x05, 0x3d, 0xc1, 0xdf, 0x79, 0x67, 0x1c, 0xe1, 0x9d, 0x21, 0xa0, 0xfb, + 0xf6, 0x47, 0x61, 0xdf, 0x79, 0x7a, 0xf7, 0xf9, 0x77, 0x97, 0x40, 0x29, 0x74, 0xf1, 0x1c, 0xf9, + 0x23, 0x12, 0x8c, 0x5e, 0x34, 0x3c, 0xdf, 0x76, 0x0d, 0x5d, 0x33, 0xe9, 0xcd, 0x85, 0x33, 0xbd, + 0x0e, 0x91, 0x4d, 0x43, 0xc9, 0x53, 0x30, 0x70, 0x5d, 0x33, 0xd9, 0x6f, 0xc8, 0x25, 0xe9, 0x0f, + 0x2d, 0xb4, 0x37, 0x44, 0x31, 0x98, 0x23, 0x09, 0x06, 0x8c, 0x4c, 0xfe, 0xc5, 0x04, 0x8c, 0xd1, + 0x64, 0xeb, 0xb1, 0x9f, 0xe0, 0x21, 0xf3, 0xf1, 0x32, 0xa4, 0x5c, 0xcd, 0xe7, 0x6b, 0x58, 0xe5, + 0x22, 0xef, 0xe3, 0xfb, 0xbb, 0xf7, 0x5b, 0x91, 0xb8, 0x01, 0xa5, 0x45, 0x3f, 0x0e, 0x99, 0xba, + 0xb6, 0xab, 0x52, 0x3e, 0xcc, 0x15, 0xe7, 0xfa, 0xe3, 0x73, 0xfb, 0xd6, 0xf4, 0xd8, 0x9e, 0x56, + 0x37, 0x4b, 0xb2, 0xe0, 0x23, 0x2b, 0x83, 0x75, 0x6d, 0x97, 0x88, 0x88, 0x1c, 0x18, 0x23, 0x50, + 0x7d, 0x47, 0xb3, 0x6a, 0x98, 0x35, 0x42, 0x57, 0xe4, 0xca, 0x17, 0xfb, 0x6e, 0xe4, 0x48, 0xd8, + 0x48, 0x84, 0x9d, 0xac, 0x8c, 0xd4, 0xb5, 0xdd, 0x79, 0x0a, 0x20, 0x2d, 0x96, 0x32, 0x9f, 0xf8, + 0xec, 0xf4, 0x21, 0x1a, 0x37, 0xdf, 0x94, 0x00, 0x42, 0x8b, 0xa1, 0x1f, 0x87, 0x9c, 0x1e, 0xbc, + 0x51, 0x5a, 0x8f, 0xf7, 0xe1, 0x03, 0x9d, 0xfa, 0xa2, 0xc9, 0xde, 0xac, 0xc4, 0xfa, 0xc6, 0xad, + 0x69, 0x49, 0x19, 0xd3, 0x9b, 0xba, 0xe2, 0x3d, 0x30, 0xd4, 0x70, 0xaa, 0x9a, 0x8f, 0x55, 0x3a, + 0xe7, 0x4f, 0x74, 0x2d, 0xd7, 0xa6, 0x08, 0xaf, 0xdb, 0xb7, 0xa6, 0x11, 0x53, 0x2b, 0x42, 0x2c, + 0xd3, 0x22, 0x0e, 0x18, 0x84, 0x10, 0x44, 0x74, 0xfa, 0x1d, 0x09, 0x86, 0x16, 0x22, 0x27, 0x88, + 0xf2, 0x30, 0x58, 0xb7, 0x2d, 0xe3, 0x1a, 0x16, 0x9b, 0x6b, 0xe2, 0x15, 0x15, 0x20, 0xc3, 0x2e, + 0x73, 0xf9, 0x7b, 0x62, 0x65, 0x4e, 0xbc, 0x13, 0xaa, 0x1b, 0x78, 0xcb, 0x33, 0x44, 0x6f, 0x28, + 0xe2, 0x15, 0x5d, 0x80, 0x9c, 0x87, 0xf5, 0x86, 0x6b, 0xf8, 0x7b, 0xaa, 0x6e, 0x5b, 0xbe, 0xa6, + 0xf3, 0x5d, 0xb7, 0xf2, 0xb1, 0xdb, 0xb7, 0xa6, 0xef, 0x62, 0xb2, 0x36, 0x63, 0xc8, 0xca, 0x98, + 0x00, 0xcd, 0x33, 0x08, 0x69, 0xa1, 0x8a, 0x7d, 0xcd, 0x30, 0x3d, 0xb6, 0x39, 0xa7, 0x88, 0xd7, + 0x88, 0x2e, 0xff, 0x78, 0x10, 0xb2, 0x81, 0xb7, 0xa3, 0x1b, 0x90, 0xb3, 0x1d, 0xec, 0xc6, 0xe6, + 0x13, 0xb4, 0x9c, 0x2a, 0x2f, 0x87, 0x2d, 0x37, 0x63, 0xc8, 0xff, 0xef, 0xd6, 0xf4, 0x23, 0x3d, + 0x78, 0xd0, 0x55, 0xcd, 0xe4, 0x73, 0x11, 0x65, 0x4c, 0xf0, 0x10, 0x93, 0x93, 0x0b, 0xc4, 0x2f, + 0xc4, 0x2a, 0x84, 0xd3, 0xd8, 0x12, 0x2b, 0xc0, 0x31, 0x95, 0x9b, 0x31, 0x64, 0xe2, 0x01, 0x1c, + 0xb4, 0x4e, 0x21, 0x64, 0x02, 0xf1, 0x9c, 0x66, 0x98, 0xe2, 0x86, 0xab, 0xc2, 0xdf, 0xd0, 0x12, + 0x0c, 0x78, 0xbe, 0xe6, 0x37, 0x58, 0x0d, 0x99, 0x2e, 0x3f, 0xd6, 0xa3, 0xcc, 0x65, 0xdb, 0xaa, + 0x6e, 0x50, 0x42, 0x85, 0x33, 0x40, 0x17, 0x60, 0xc0, 0xb7, 0xaf, 0x61, 0x8b, 0x1b, 0xb5, 0xaf, + 0x88, 0xa7, 0x63, 0x14, 0xa3, 0x46, 0x3e, 0xe4, 0xaa, 0xd8, 0xc4, 0x35, 0x6a, 0x4a, 0x6f, 0x47, + 0x23, 0xf3, 0x54, 0xba, 0x55, 0x5a, 0x5e, 0xea, 0x3b, 0x2c, 0xb9, 0x81, 0x9a, 0xf9, 0xc9, 0xca, + 0x58, 0x00, 0xda, 0xa0, 0x10, 0x74, 0x39, 0x76, 0xf8, 0x8d, 0xff, 0x64, 0xdb, 0xbd, 0x9d, 0x62, + 0x2f, 0xe2, 0xe5, 0x62, 0x75, 0x2b, 0x7a, 0x74, 0xee, 0x02, 0xe4, 0x1a, 0xd6, 0x96, 0x4d, 0x37, + 0x51, 0x55, 0x3e, 0x71, 0xcb, 0x90, 0x7a, 0x26, 0xda, 0x6b, 0xcd, 0x18, 0xb2, 0x32, 0x16, 0x80, + 0x2e, 0xb2, 0xe9, 0x5d, 0x15, 0x46, 0x43, 0x2c, 0x1a, 0xba, 0xd9, 0xae, 0xa1, 0x7b, 0x0f, 0x0f, + 0xdd, 0xc3, 0xcd, 0xad, 0x84, 0xd1, 0x3b, 0x12, 0x00, 0x09, 0x19, 0xba, 0x08, 0x10, 0x26, 0x0c, + 0xba, 0xca, 0x35, 0x74, 0x4a, 0xee, 0x9e, 0x75, 0xc4, 0xca, 0x40, 0x48, 0x8b, 0xde, 0x07, 0x13, + 0x75, 0xc3, 0x52, 0x3d, 0x6c, 0x6e, 0xab, 0xdc, 0xc0, 0x84, 0x25, 0xfd, 0x51, 0x91, 0xf2, 0x72, + 0x7f, 0xfe, 0x70, 0xfb, 0xd6, 0x74, 0x81, 0x27, 0xd5, 0x56, 0x96, 0xb2, 0x32, 0x5e, 0x37, 0xac, + 0x0d, 0x6c, 0x6e, 0x2f, 0x04, 0xb0, 0xd2, 0xf0, 0x4f, 0x7f, 0x76, 0xfa, 0x50, 0x10, 0xc0, 0x06, + 0x0c, 0x87, 0x81, 0x85, 0x3d, 0xb4, 0x06, 0x59, 0x4d, 0xbc, 0xb0, 0xf5, 0xb0, 0x9e, 0x9d, 0x3d, + 0x12, 0xa0, 0x21, 0x0f, 0x96, 0x2b, 0x5e, 0xf8, 0xf7, 0x33, 0x92, 0xfc, 0x62, 0x02, 0x06, 0x16, + 0xae, 0xae, 0x6b, 0x86, 0x8b, 0x6e, 0xc2, 0x78, 0xe8, 0x6c, 0xf1, 0x4c, 0xb1, 0x72, 0xfb, 0xd6, + 0x74, 0xbe, 0xd9, 0x1f, 0xfb, 0x4c, 0x15, 0x73, 0xba, 0x2e, 0x24, 0x09, 0x83, 0x44, 0xe4, 0x8a, + 0x9b, 0x1d, 0x57, 0x3d, 0xa2, 0x6d, 0xb7, 0xa0, 0x1c, 0x20, 0x4d, 0xb5, 0x2c, 0xa2, 0x44, 0x12, + 0x67, 0x05, 0x06, 0x99, 0x2d, 0x3c, 0x54, 0x82, 0xb4, 0x43, 0x1e, 0xf8, 0x0e, 0xd4, 0x54, 0xc7, + 0x68, 0xa2, 0xf8, 0xc1, 0xba, 0x3c, 0x21, 0x91, 0x3f, 0x9f, 0x04, 0x58, 0xb8, 0x7a, 0x75, 0xd3, + 0x35, 0x1c, 0x13, 0xfb, 0x3f, 0x54, 0xbb, 0x7e, 0x48, 0x82, 0xc3, 0xa1, 0xd5, 0x3c, 0x57, 0x6f, + 0x32, 0xee, 0xd3, 0xb7, 0x6f, 0x4d, 0x1f, 0x6f, 0x36, 0x6e, 0x04, 0xed, 0x00, 0x06, 0x9e, 0x08, + 0x18, 0x6d, 0xb8, 0x7a, 0x7b, 0x39, 0xaa, 0x9e, 0x1f, 0xc8, 0x91, 0xec, 0x2c, 0x47, 0x04, 0xed, + 0x35, 0xc9, 0xb1, 0xe0, 0xf9, 0xad, 0x7d, 0xbd, 0x01, 0x43, 0x61, 0x1f, 0x79, 0x68, 0x01, 0x32, + 0x3e, 0x7f, 0xe6, 0x5d, 0x2e, 0x77, 0xee, 0x72, 0x41, 0xc6, 0xbb, 0x3d, 0xa0, 0x94, 0xff, 0x4d, + 0x02, 0x20, 0x8c, 0xea, 0x3f, 0xad, 0x11, 0x45, 0x86, 0x53, 0x3e, 0xf8, 0x25, 0x0f, 0x54, 0x40, + 0x73, 0xea, 0x48, 0x6f, 0xfd, 0x61, 0x02, 0x26, 0xae, 0x88, 0xcc, 0xff, 0x96, 0x85, 0xd1, 0x3a, + 0x0c, 0x62, 0xcb, 0x77, 0x0d, 0x6a, 0x62, 0xe2, 0xad, 0x8f, 0x76, 0xf2, 0xd6, 0x36, 0x56, 0xa3, + 0x3f, 0x9c, 0x23, 0x36, 0xe5, 0x38, 0x9b, 0x88, 0xad, 0x3f, 0x9a, 0x84, 0x7c, 0x27, 0x2a, 0x34, + 0x0f, 0x63, 0xba, 0x8b, 0x29, 0x40, 0x8d, 0xee, 0x00, 0x94, 0x0b, 0xe1, 0x4c, 0xa2, 0x09, 0x41, + 0x56, 0x46, 0x05, 0x84, 0xd7, 0x06, 0x35, 0x20, 0x65, 0x3e, 0x09, 0x19, 0x82, 0xd5, 0x63, 0x5d, + 0x2f, 0xf3, 0xe2, 0x40, 0x34, 0x12, 0x67, 0xc0, 0xaa, 0x83, 0xd1, 0x10, 0x4a, 0xcb, 0x83, 0xe7, + 0x61, 0xcc, 0xb0, 0x0c, 0xdf, 0xd0, 0x4c, 0x75, 0x4b, 0x33, 0x35, 0x4b, 0x3f, 0xc8, 0x2c, 0x89, + 0x0d, 0xe8, 0xbc, 0xd9, 0x26, 0x76, 0xb2, 0x32, 0xca, 0x21, 0x65, 0x06, 0x40, 0x17, 0x61, 0x50, + 0x34, 0x95, 0x3a, 0x50, 0x2d, 0x29, 0xc8, 0x23, 0x3d, 0xf2, 0x33, 0x49, 0x18, 0x57, 0x70, 0xf5, + 0xad, 0xae, 0xe8, 0xaf, 0x2b, 0x56, 0x00, 0x58, 0x22, 0x21, 0x23, 0xc9, 0x01, 0x7a, 0x83, 0xa4, + 0xa2, 0x2c, 0xe3, 0xb0, 0xe0, 0xf9, 0x91, 0xfe, 0xf8, 0xa3, 0x24, 0x0c, 0x47, 0xfb, 0xe3, 0xad, + 0x21, 0xfe, 0x47, 0x67, 0x88, 0x47, 0x4b, 0x61, 0x6a, 0x4c, 0xf1, 0xdf, 0x3f, 0xed, 0x90, 0x1a, + 0x5b, 0x42, 0xaa, 0x73, 0x4e, 0xfc, 0x5f, 0x09, 0x18, 0x58, 0xd7, 0x5c, 0xad, 0xee, 0x21, 0xbd, + 0x65, 0x62, 0x23, 0xf6, 0x57, 0x5a, 0x7e, 0xe1, 0x9a, 0x2f, 0x8a, 0x75, 0x99, 0xd7, 0x7c, 0xa2, + 0xcd, 0xbc, 0xe6, 0x9d, 0x30, 0x5a, 0xd7, 0x76, 0x23, 0x5b, 0xfe, 0xb4, 0x33, 0x47, 0xca, 0x47, + 0x43, 0x2e, 0xf1, 0xef, 0x6c, 0xb9, 0x26, 0x3c, 0x07, 0x80, 0xce, 0xc2, 0x10, 0xc1, 0x08, 0x47, + 0x09, 0x42, 0x7e, 0x24, 0x5c, 0x17, 0x89, 0x7c, 0x94, 0x15, 0xa8, 0x6b, 0xbb, 0x15, 0xf6, 0x82, + 0x96, 0x01, 0xed, 0x04, 0x4b, 0x73, 0x6a, 0x68, 0x4a, 0x42, 0x7f, 0xf7, 0xed, 0x5b, 0xd3, 0x47, + 0x19, 0x7d, 0x2b, 0x8e, 0xac, 0x8c, 0x87, 0x40, 0xc1, 0xed, 0x34, 0x00, 0xd1, 0x4b, 0x65, 0x2b, + 0xb5, 0x6c, 0x76, 0x7d, 0xf8, 0xf6, 0xad, 0xe9, 0x71, 0xc6, 0x25, 0xfc, 0x26, 0x2b, 0x59, 0xf2, + 0xb2, 0x40, 0x9e, 0x23, 0x86, 0xff, 0x82, 0x04, 0x28, 0x1c, 0x83, 0x82, 0x7f, 0xed, 0x70, 0x11, + 0x20, 0x32, 0x49, 0x93, 0xf6, 0x9f, 0xf7, 0x85, 0xf4, 0x62, 0xde, 0x17, 0x09, 0xdd, 0x27, 0xc3, + 0x7c, 0x9d, 0xe0, 0xfd, 0xd8, 0x66, 0x59, 0xbb, 0x38, 0x6f, 0x1b, 0x82, 0xba, 0x4d, 0x82, 0xfe, + 0xe7, 0x12, 0x1c, 0x6d, 0xf1, 0xa6, 0x40, 0xd8, 0x3f, 0x03, 0xc8, 0x8d, 0x7c, 0xe4, 0x3f, 0x64, + 0xc7, 0x84, 0xee, 0xdb, 0x39, 0xc7, 0xdd, 0x96, 0x81, 0xe0, 0xce, 0x0d, 0x39, 0x6c, 0x5d, 0xfc, + 0x9f, 0x48, 0x30, 0x19, 0x6d, 0x3e, 0x50, 0x64, 0x15, 0x86, 0xa3, 0xad, 0x73, 0x15, 0xee, 0xeb, + 0x45, 0x05, 0x2e, 0x7d, 0x8c, 0x1e, 0x3d, 0x1d, 0x86, 0x2a, 0x5b, 0xbc, 0x7d, 0xac, 0x67, 0x6b, + 0x08, 0x99, 0x9a, 0x43, 0x96, 0x69, 0xf0, 0x27, 0x12, 0xa4, 0xd6, 0x6d, 0xdb, 0x44, 0x36, 0x8c, + 0x5b, 0xb6, 0xaf, 0x12, 0xcf, 0xc2, 0x55, 0x95, 0xaf, 0xf1, 0xb0, 0x55, 0xdd, 0xf9, 0xfe, 0x8c, + 0xf4, 0xfd, 0x5b, 0xd3, 0xad, 0xac, 0x94, 0x31, 0xcb, 0xf6, 0xcb, 0x14, 0xb2, 0xc9, 0x56, 0x80, + 0xde, 0x07, 0x23, 0xf1, 0xc6, 0xd8, 0x8a, 0xd7, 0x33, 0x7d, 0x37, 0x16, 0x67, 0x73, 0xfb, 0xd6, + 0xf4, 0x64, 0x18, 0x31, 0x01, 0x58, 0x56, 0x86, 0xb7, 0x22, 0xad, 0x97, 0x32, 0x44, 0xfb, 0x3f, + 0xfe, 0xec, 0xb4, 0x54, 0xbe, 0xd0, 0x71, 0xf7, 0xe1, 0xe1, 0x7d, 0x45, 0xd8, 0x0d, 0xb6, 0x19, + 0xe2, 0xfb, 0x10, 0x9f, 0x39, 0x0f, 0x72, 0x87, 0x7d, 0x08, 0xf6, 0x4f, 0x5f, 0xf6, 0xdf, 0x85, + 0xe8, 0xe3, 0x3f, 0xca, 0x74, 0xda, 0xb1, 0xd8, 0xef, 0x44, 0x7b, 0xa1, 0xa7, 0x3d, 0x12, 0x79, + 0x17, 0x8e, 0x3c, 0x4d, 0xda, 0x0e, 0xd3, 0xa4, 0xf8, 0xdf, 0x34, 0x47, 0x82, 0xb5, 0x44, 0x89, + 0xff, 0x67, 0x0b, 0xb1, 0x30, 0x08, 0xa1, 0x7c, 0x3c, 0x41, 0xdc, 0x5f, 0xec, 0xf8, 0x2f, 0x6f, + 0x8a, 0x91, 0xff, 0x77, 0xa3, 0x44, 0x28, 0xe5, 0x5f, 0x90, 0xe0, 0xae, 0x96, 0xa6, 0x79, 0x54, + 0x2d, 0x02, 0x44, 0xf2, 0xbc, 0xd4, 0xdf, 0x2e, 0x46, 0x84, 0x94, 0x30, 0x6a, 0x11, 0xf6, 0x81, + 0xae, 0xc2, 0x32, 0x29, 0x62, 0xd2, 0x3e, 0x0f, 0x87, 0xe3, 0xc2, 0x0a, 0x33, 0x3d, 0x0b, 0xa3, + 0xf1, 0xf9, 0x0c, 0x2f, 0x72, 0x0e, 0xb0, 0x1a, 0x35, 0x12, 0x9b, 0xd3, 0xc8, 0x6a, 0x73, 0xd7, + 0x04, 0xe6, 0xa9, 0x40, 0x36, 0x40, 0xe5, 0x19, 0xa7, 0x67, 0xeb, 0x84, 0x94, 0xf2, 0xd7, 0x24, + 0x98, 0x89, 0xb7, 0x10, 0x0e, 0x0b, 0xde, 0xeb, 0xae, 0xdf, 0x1d, 0x73, 0xa4, 0xef, 0x49, 0x70, + 0xcf, 0x3e, 0x6a, 0x70, 0x9b, 0xdd, 0x84, 0xc9, 0xc8, 0x78, 0x23, 0x6e, 0xbc, 0x08, 0xe7, 0x3a, + 0xd9, 0x7d, 0xa0, 0x0c, 0xd2, 0xeb, 0x31, 0x62, 0xc7, 0x2f, 0x7d, 0x7b, 0x7a, 0xa2, 0xf5, 0x9b, + 0xa7, 0x4c, 0xb4, 0x8e, 0x11, 0x77, 0xd0, 0x0b, 0x7f, 0x57, 0x82, 0x07, 0xe3, 0xaa, 0xb6, 0x99, + 0x95, 0xbe, 0x89, 0xba, 0xee, 0xdf, 0x49, 0x70, 0xb2, 0x17, 0x7d, 0x78, 0x1f, 0x6e, 0xc1, 0x44, + 0x58, 0x28, 0x36, 0x77, 0xe1, 0x43, 0x7d, 0x4c, 0xf7, 0x79, 0x2c, 0xa0, 0x80, 0xdb, 0xeb, 0xd0, + 0x57, 0xff, 0x42, 0xe2, 0xf1, 0x1b, 0x75, 0x93, 0xa0, 0x63, 0xe2, 0x13, 0x9f, 0x3e, 0x3b, 0x26, + 0x32, 0xf9, 0x19, 0x89, 0x4d, 0x7e, 0xda, 0x74, 0x79, 0xe2, 0x0e, 0x65, 0xa3, 0xeb, 0x3c, 0x5b, + 0xb7, 0xa9, 0x3c, 0xdf, 0x03, 0x13, 0x6d, 0x42, 0x8b, 0x27, 0xa6, 0x3e, 0x22, 0x4b, 0x41, 0xad, + 0xc1, 0x23, 0xff, 0x6b, 0x09, 0xa6, 0x69, 0xc3, 0x6d, 0xba, 0xf1, 0xcd, 0x6c, 0xcf, 0x3a, 0xcf, + 0xbd, 0x6d, 0xd5, 0xe2, 0x86, 0x5d, 0x82, 0x01, 0xe6, 0xa1, 0xdc, 0x96, 0x07, 0x70, 0x71, 0xce, + 0x20, 0xcc, 0xf5, 0x0b, 0x42, 0xbf, 0xf6, 0x09, 0xe3, 0x75, 0xb2, 0xe3, 0x9d, 0x4a, 0x18, 0xdf, + 0x14, 0xb9, 0xbe, 0xbd, 0x1a, 0xdc, 0x6e, 0xfa, 0x1d, 0xcb, 0xf5, 0xcc, 0x88, 0x6f, 0x50, 0x52, + 0x0f, 0x74, 0xea, 0x92, 0xd4, 0x7f, 0xc4, 0xfb, 0x28, 0x48, 0xea, 0x5d, 0xf4, 0x79, 0x33, 0x26, + 0xf5, 0x3f, 0x49, 0xc0, 0x51, 0xaa, 0x5b, 0x74, 0xf6, 0xf5, 0x06, 0xf4, 0x8d, 0x0a, 0xc8, 0x73, + 0x75, 0xf5, 0x4e, 0xe5, 0xa2, 0x9c, 0xe7, 0xea, 0x57, 0x63, 0x23, 0xba, 0x0a, 0xa8, 0xea, 0xf9, + 0xcd, 0x0d, 0x24, 0x0f, 0xdc, 0x40, 0xd5, 0xf3, 0xaf, 0xee, 0x53, 0x32, 0xa4, 0x0e, 0xec, 0x5d, + 0xdf, 0x90, 0xa0, 0xd0, 0xae, 0x07, 0xb8, 0x37, 0x19, 0x70, 0x24, 0xb6, 0xb0, 0xd0, 0xec, 0x50, + 0x0f, 0xf7, 0x32, 0x9d, 0x6e, 0x0a, 0xff, 0xc3, 0x2e, 0x7e, 0x5d, 0x13, 0xc0, 0x6f, 0x88, 0x21, + 0x2e, 0x08, 0x98, 0xd6, 0xd9, 0xd8, 0x8f, 0x7e, 0xd8, 0xff, 0x4a, 0xcb, 0x08, 0xf3, 0xa6, 0x98, + 0xd8, 0x7d, 0x4b, 0x82, 0xa9, 0x0e, 0x62, 0xbf, 0x99, 0xcb, 0x8b, 0x9d, 0x8e, 0x2e, 0x75, 0xa7, + 0x67, 0x91, 0xa7, 0x79, 0x3c, 0xc6, 0x0f, 0x2f, 0x46, 0x56, 0x11, 0xda, 0xdd, 0x8a, 0x91, 0xdf, + 0x05, 0xc7, 0xda, 0x52, 0x71, 0xd9, 0x4a, 0x90, 0xda, 0x31, 0x3c, 0x9f, 0x8b, 0x75, 0x7f, 0x27, + 0xb1, 0x9a, 0xa8, 0x29, 0x8d, 0x8c, 0x20, 0x47, 0x59, 0xaf, 0xdb, 0xb6, 0xc9, 0xc5, 0x90, 0x2f, + 0xc3, 0x78, 0x04, 0xc6, 0x1b, 0x39, 0x03, 0x29, 0xc7, 0xe6, 0x17, 0x4d, 0x87, 0x4e, 0x1d, 0xef, + 0xd4, 0x08, 0xa1, 0xe1, 0x6a, 0x53, 0x7c, 0x79, 0x12, 0x10, 0x63, 0x46, 0x57, 0xbf, 0x45, 0x13, + 0x1b, 0x30, 0x11, 0x83, 0xf2, 0x46, 0x7e, 0x0c, 0x06, 0x1c, 0x0a, 0xe1, 0xcd, 0x74, 0x3c, 0x36, + 0xc1, 0xe8, 0x44, 0xd9, 0xc6, 0x68, 0x4e, 0x7d, 0xff, 0x30, 0xa4, 0x29, 0x57, 0xf4, 0x49, 0x09, + 0x20, 0xb2, 0x96, 0x5d, 0xec, 0xc4, 0xa6, 0xfd, 0x6a, 0x4e, 0x61, 0xb6, 0x67, 0x7c, 0x5e, 0x77, + 0x9f, 0xfc, 0xa9, 0x7f, 0xf5, 0xdd, 0x9f, 0x4d, 0xdc, 0x87, 0xe4, 0xd9, 0x0e, 0xeb, 0x48, 0x91, + 0x60, 0xfc, 0xa2, 0x14, 0x3d, 0x5d, 0xf7, 0x48, 0x6f, 0x4d, 0x09, 0xc9, 0x8a, 0xbd, 0xa2, 0x73, + 0xc1, 0xce, 0x53, 0xc1, 0x9e, 0x40, 0x8f, 0x77, 0x17, 0x6c, 0xf6, 0xbd, 0xf1, 0xe8, 0x7a, 0x3f, + 0xfa, 0x96, 0x04, 0x93, 0xed, 0x96, 0x09, 0xd0, 0xb9, 0xde, 0xa4, 0x68, 0x2d, 0xc8, 0x0a, 0x4f, + 0x1e, 0x80, 0x92, 0xab, 0xb2, 0x48, 0x55, 0x99, 0x43, 0x4f, 0x1d, 0x40, 0x95, 0xd9, 0xc8, 0xe8, + 0x87, 0xfe, 0xaf, 0x04, 0x77, 0xef, 0x3b, 0x85, 0x46, 0x73, 0xbd, 0x49, 0xb9, 0x4f, 0xe5, 0x59, + 0x28, 0xbf, 0x16, 0x16, 0x5c, 0xe3, 0xa7, 0xa9, 0xc6, 0x97, 0xd1, 0xd2, 0x41, 0x34, 0x0e, 0xcb, + 0xc4, 0xa8, 0xee, 0xbf, 0x2d, 0xc5, 0x0e, 0x98, 0xec, 0xef, 0x4e, 0x2d, 0x73, 0xc7, 0x2e, 0x81, + 0xd1, 0x3a, 0x25, 0x90, 0x9f, 0xa5, 0x2a, 0x28, 0x68, 0xfd, 0x35, 0x76, 0xda, 0xec, 0x7b, 0xe3, + 0x83, 0xca, 0xfb, 0xd1, 0xff, 0x96, 0xda, 0x9f, 0xe8, 0x38, 0xbb, 0xaf, 0x88, 0x9d, 0xe7, 0xc5, + 0x85, 0x73, 0xfd, 0x13, 0x72, 0x25, 0xeb, 0x54, 0xc9, 0x1a, 0xc2, 0x77, 0x5a, 0xc9, 0xb6, 0x9d, + 0x88, 0x7e, 0x47, 0x82, 0xc9, 0x76, 0x33, 0xba, 0x2e, 0x61, 0xb9, 0xcf, 0x5c, 0xb6, 0x4b, 0x58, + 0xee, 0x37, 0x7d, 0x94, 0x7f, 0x8c, 0x2a, 0x7f, 0x06, 0x9d, 0xee, 0xa4, 0xfc, 0xbe, 0xbd, 0x48, + 0x62, 0x71, 0xdf, 0x99, 0x4f, 0x97, 0x58, 0xec, 0x65, 0x16, 0xd8, 0x25, 0x16, 0x7b, 0x9a, 0x78, + 0x75, 0x8f, 0xc5, 0x40, 0xb3, 0x1e, 0xbb, 0xd1, 0x43, 0x5f, 0x95, 0x60, 0x24, 0x56, 0x97, 0xa3, + 0xc7, 0xf6, 0x15, 0xb4, 0xdd, 0x2c, 0xaa, 0x70, 0xaa, 0x1f, 0x12, 0xae, 0xcb, 0x12, 0xd5, 0x65, + 0x1e, 0xcd, 0x1d, 0x44, 0x17, 0x37, 0x26, 0xf1, 0x37, 0x24, 0x98, 0x68, 0x53, 0xc2, 0x76, 0x89, + 0xc2, 0xce, 0xa5, 0x7b, 0xe1, 0x5c, 0xff, 0x84, 0x5c, 0xab, 0x0b, 0x54, 0xab, 0x77, 0xa2, 0x77, + 0x1c, 0x44, 0xab, 0xc8, 0xf8, 0x7c, 0x2b, 0xdc, 0x31, 0x8e, 0xb4, 0x83, 0xce, 0xf4, 0x29, 0x98, + 0x50, 0xe8, 0x6c, 0xdf, 0x74, 0x5c, 0x9f, 0x67, 0xa8, 0x3e, 0x4f, 0xa3, 0xb5, 0xd7, 0xa6, 0x4f, + 0xeb, 0xb0, 0xfe, 0xe5, 0xd6, 0xcb, 0x33, 0xfb, 0x7b, 0x51, 0xdb, 0x62, 0xb5, 0xf0, 0x78, 0x5f, + 0x34, 0x5c, 0xa9, 0x73, 0x54, 0xa9, 0x53, 0xe8, 0xd1, 0x4e, 0x4a, 0x45, 0x8e, 0x05, 0x18, 0xd6, + 0xb6, 0x3d, 0xfb, 0x5e, 0x56, 0x02, 0xbf, 0x1f, 0xfd, 0xa4, 0xd8, 0x92, 0x3d, 0xb1, 0x6f, 0xbb, + 0x91, 0x3a, 0xb6, 0xf0, 0x60, 0x0f, 0x98, 0x5c, 0xae, 0xfb, 0xa8, 0x5c, 0x53, 0xe8, 0x78, 0x27, + 0xb9, 0x48, 0x2d, 0x8b, 0x3e, 0x22, 0x05, 0xa7, 0x38, 0x4e, 0xee, 0xcf, 0x3b, 0x5a, 0xec, 0x16, + 0x1e, 0xea, 0x09, 0x97, 0x4b, 0x72, 0x3f, 0x95, 0x64, 0x06, 0x4d, 0x75, 0x94, 0x84, 0x95, 0xbe, + 0x77, 0x7a, 0x83, 0xf6, 0x13, 0x13, 0x30, 0xdd, 0xa1, 0x45, 0x7f, 0xf7, 0x40, 0x77, 0xc4, 0xba, + 0x5c, 0xe2, 0xea, 0x71, 0xcf, 0xf5, 0xd5, 0x14, 0xa0, 0x15, 0xaf, 0x36, 0xef, 0x62, 0xf6, 0x0f, + 0x83, 0x78, 0x38, 0x36, 0xdd, 0x59, 0x90, 0x5e, 0xd3, 0x9d, 0x85, 0x95, 0xd8, 0x2d, 0x80, 0x44, + 0x7f, 0x77, 0x8f, 0x7a, 0xbe, 0x0a, 0x90, 0x7c, 0x43, 0xae, 0x02, 0xb4, 0x3f, 0x4b, 0x96, 0xfa, + 0x21, 0x1e, 0x69, 0x4d, 0xbf, 0x31, 0x47, 0x5a, 0x8f, 0xc0, 0x00, 0xbf, 0x24, 0xc4, 0xfe, 0x7f, + 0x3b, 0x7f, 0x43, 0x4f, 0x88, 0xff, 0x66, 0x3d, 0xd8, 0xdb, 0xf1, 0x1c, 0x86, 0xcd, 0x0f, 0x82, + 0x7c, 0x25, 0x09, 0xb9, 0x15, 0xaf, 0x56, 0xa9, 0x1a, 0xfe, 0xeb, 0xe4, 0x7b, 0x4e, 0xe7, 0x53, + 0xc0, 0xf3, 0xb7, 0x6f, 0x4d, 0x8f, 0x32, 0x93, 0xdd, 0x49, 0x43, 0xd5, 0x61, 0xac, 0xe9, 0xbe, + 0x1d, 0x77, 0xcd, 0x85, 0x83, 0x5c, 0xfb, 0x6b, 0x62, 0x25, 0xd3, 0x83, 0x9b, 0x91, 0x00, 0x41, + 0xbb, 0xed, 0xa3, 0x81, 0x9d, 0x34, 0xba, 0xf8, 0x7a, 0x5e, 0x8a, 0x61, 0x5d, 0xf8, 0xb5, 0x04, + 0x0c, 0xad, 0x78, 0xa2, 0xa8, 0xc3, 0x7f, 0x6a, 0x8f, 0x7c, 0x9f, 0x0d, 0x2e, 0x36, 0x27, 0x7b, + 0x0b, 0x84, 0xf8, 0x65, 0xe7, 0x6f, 0x27, 0x69, 0x1e, 0x2e, 0xe3, 0x9a, 0x61, 0x05, 0x65, 0x25, + 0x7e, 0xeb, 0xe4, 0xea, 0x8f, 0xd0, 0xc9, 0xd5, 0xb0, 0x87, 0x53, 0x07, 0xe9, 0xe1, 0xdf, 0x4a, + 0xc0, 0xc8, 0x8a, 0x57, 0xbb, 0x62, 0x55, 0xdf, 0x0a, 0x95, 0xd7, 0x12, 0x2a, 0x77, 0xbc, 0x34, + 0xfb, 0x54, 0xa6, 0xe3, 0x1d, 0xfe, 0x1a, 0xb6, 0xb0, 0x67, 0x78, 0x07, 0xaa, 0xcf, 0x7a, 0xab, + 0xbf, 0xbe, 0x95, 0x86, 0xe1, 0x45, 0xd6, 0xca, 0x86, 0x4f, 0x9c, 0xe2, 0x35, 0xad, 0xd1, 0x22, + 0x8f, 0xff, 0xf8, 0x19, 0xfd, 0xfd, 0x3b, 0xd5, 0xb1, 0x6f, 0x60, 0xb1, 0x8c, 0xbf, 0xd4, 0x77, + 0x61, 0xc4, 0x2f, 0x93, 0x36, 0xf3, 0x93, 0xd9, 0xef, 0xa8, 0x6d, 0x12, 0xc8, 0x3a, 0x01, 0xa0, + 0x0f, 0x4a, 0x70, 0x98, 0x62, 0x85, 0xee, 0x42, 0x31, 0xc5, 0xe5, 0x97, 0x8e, 0xc5, 0xfc, 0xb2, + 0x16, 0xd9, 0x99, 0xa3, 0xbc, 0xca, 0xf7, 0xf1, 0xb3, 0xd8, 0xc7, 0x23, 0x8d, 0x37, 0xb3, 0x95, + 0x95, 0x09, 0xb3, 0x85, 0xd2, 0x6b, 0xda, 0xcf, 0x49, 0x1d, 0x7c, 0x3f, 0xe7, 0x12, 0x29, 0x40, + 0x82, 0x49, 0x78, 0x3e, 0xdd, 0xe5, 0xbe, 0x59, 0xf3, 0xa6, 0x6f, 0x94, 0x18, 0x7d, 0x58, 0x82, + 0xc3, 0x6d, 0xd7, 0x27, 0xe8, 0x3f, 0x90, 0xec, 0x73, 0x53, 0xb9, 0xc9, 0x38, 0x6d, 0xf9, 0xca, + 0xca, 0x64, 0xa3, 0xdd, 0x42, 0xcf, 0x3a, 0x8c, 0xc4, 0xd6, 0x16, 0xf2, 0xe2, 0xdf, 0xc0, 0xf6, + 0x7e, 0x3a, 0x38, 0xce, 0x00, 0x15, 0x20, 0x83, 0x77, 0x1d, 0xdb, 0xf5, 0x71, 0x95, 0x5e, 0x41, + 0xce, 0x28, 0xc1, 0xbb, 0x7c, 0x03, 0x50, 0x6b, 0xe7, 0xa2, 0xcb, 0x30, 0x18, 0x4f, 0x73, 0x07, + 0xd8, 0x5b, 0x12, 0x1c, 0xd0, 0x24, 0xa4, 0x43, 0xff, 0x4e, 0x2a, 0xec, 0xe5, 0x4e, 0x27, 0x87, + 0xff, 0x1f, 0x00, 0x00, 0xff, 0xff, 0xbc, 0x8f, 0x19, 0xeb, 0x6f, 0x91, 0x00, 0x00, } r := bytes.NewReader(gzipped) gzipr, err := compress_gzip.NewReader(r) diff --git a/x/staking/v1beta1/query.swagger.json b/x/staking/v1beta1/query.swagger.json new file mode 100644 index 000000000000..bf0792862b2a --- /dev/null +++ b/x/staking/v1beta1/query.swagger.json @@ -0,0 +1,1385 @@ +{ + "swagger": "2.0", + "info": { + "title": "cosmos/staking/v1beta1/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/cosmos/staking/v1beta1/delegations/{delegator_addr}": { + "get": { + "summary": "DelegatorDelegations queries all delegations of a given delegator address.", + "operationId": "Query_DelegatorDelegations", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryDelegatorDelegationsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "delegator_addr", + "description": "delegator_addr defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/delegators/{delegator_addr}/redelegations": { + "get": { + "summary": "Redelegations queries redelegations of given address.", + "operationId": "Query_Redelegations", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryRedelegationsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "delegator_addr", + "description": "delegator_addr defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "src_validator_addr", + "description": "src_validator_addr defines the validator address to redelegate from.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "dst_validator_addr", + "description": "dst_validator_addr defines the validator address to redelegate to.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/delegators/{delegator_addr}/unbonding_delegations": { + "get": { + "summary": "DelegatorUnbondingDelegations queries all unbonding delegations of a given delegator address.", + "operationId": "Query_DelegatorUnbondingDelegations", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryDelegatorUnbondingDelegationsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "delegator_addr", + "description": "delegator_addr defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators": { + "get": { + "summary": "DelegatorValidators queries all validators info for given delegator address.", + "operationId": "Query_DelegatorValidators", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryDelegatorValidatorsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "delegator_addr", + "description": "delegator_addr defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators/{validator_addr}": { + "get": { + "summary": "DelegatorValidator queries validator info for given delegator validator pair.", + "operationId": "Query_DelegatorValidator", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryDelegatorValidatorResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "delegator_addr", + "description": "delegator_addr defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "validator_addr", + "description": "validator_addr defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/historical_info/{height}": { + "get": { + "summary": "HistoricalInfo queries the historical info for given height.", + "operationId": "Query_HistoricalInfo", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryHistoricalInfoResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "height", + "description": "height defines at which height to query the historical info.", + "in": "path", + "required": true, + "type": "string", + "format": "int64" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/params": { + "get": { + "summary": "Parameters queries the staking parameters.", + "operationId": "Query_Params", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryParamsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/pool": { + "get": { + "summary": "Pool queries the pool info.", + "operationId": "Query_Pool", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryPoolResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/validators": { + "get": { + "summary": "Validators queries all validators that match the given status.", + "operationId": "Query_Validators", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryValidatorsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "status", + "description": "status enables to query for validators matching a given status.", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/validators/{validator_addr}": { + "get": { + "summary": "Validator queries validator info for given validator address.", + "operationId": "Query_Validator", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryValidatorResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "validator_addr", + "description": "validator_addr defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/validators/{validator_addr}/delegations": { + "get": { + "summary": "ValidatorDelegations queries delegate info for given validator.", + "operationId": "Query_ValidatorDelegations", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryValidatorDelegationsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "validator_addr", + "description": "validator_addr defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}": { + "get": { + "summary": "Delegation queries delegate info for given validator delegator pair.", + "operationId": "Query_Delegation", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryDelegationResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "validator_addr", + "description": "validator_addr defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "delegator_addr", + "description": "delegator_addr defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}/unbonding_delegation": { + "get": { + "summary": "UnbondingDelegation queries unbonding info for given validator delegator pair.", + "operationId": "Query_UnbondingDelegation", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryUnbondingDelegationResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "validator_addr", + "description": "validator_addr defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "delegator_addr", + "description": "delegator_addr defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/validators/{validator_addr}/unbonding_delegations": { + "get": { + "summary": "ValidatorUnbondingDelegations queries unbonding delegations of a validator.", + "operationId": "Query_ValidatorUnbondingDelegations", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryValidatorUnbondingDelegationsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "validator_addr", + "description": "validator_addr defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "protobufAny": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + }, + "runtimeError": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/protobufAny" + } + } + } + }, + "typesBlockID": { + "type": "object", + "properties": { + "hash": { + "type": "string", + "format": "byte" + }, + "part_set_header": { + "$ref": "#/definitions/typesPartSetHeader" + } + }, + "title": "BlockID" + }, + "typesHeader": { + "type": "object", + "properties": { + "version": { + "$ref": "#/definitions/versionConsensus", + "title": "basic block info" + }, + "chain_id": { + "type": "string" + }, + "height": { + "type": "string", + "format": "int64" + }, + "time": { + "type": "string", + "format": "date-time" + }, + "last_block_id": { + "$ref": "#/definitions/typesBlockID", + "title": "prev block info" + }, + "last_commit_hash": { + "type": "string", + "format": "byte", + "title": "hashes of block data" + }, + "data_hash": { + "type": "string", + "format": "byte" + }, + "validators_hash": { + "type": "string", + "format": "byte", + "title": "hashes from the app output from the prev block" + }, + "next_validators_hash": { + "type": "string", + "format": "byte" + }, + "consensus_hash": { + "type": "string", + "format": "byte" + }, + "app_hash": { + "type": "string", + "format": "byte" + }, + "last_results_hash": { + "type": "string", + "format": "byte" + }, + "evidence_hash": { + "type": "string", + "format": "byte", + "title": "consensus info" + }, + "proposer_address": { + "type": "string", + "format": "byte" + } + }, + "description": "Header defines the structure of a Tendermint block header." + }, + "typesPartSetHeader": { + "type": "object", + "properties": { + "total": { + "type": "integer", + "format": "int64" + }, + "hash": { + "type": "string", + "format": "byte" + } + }, + "title": "PartsetHeader" + }, + "v1beta1Coin": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + }, + "v1beta1Commission": { + "type": "object", + "properties": { + "commission_rates": { + "$ref": "#/definitions/v1beta1CommissionRates" + }, + "update_time": { + "type": "string", + "format": "date-time" + } + }, + "description": "Commission defines a commission parameters for a given validator." + }, + "v1beta1CommissionRates": { + "type": "object", + "properties": { + "rate": { + "type": "string" + }, + "max_rate": { + "type": "string" + }, + "max_change_rate": { + "type": "string" + } + }, + "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + }, + "v1beta1Delegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "shares": { + "type": "string" + } + }, + "description": "Delegation represents the bond with tokens held by an account. It is\nowned by one delegator, and is associated with the voting power of one\nvalidator." + }, + "v1beta1DelegationResponse": { + "type": "object", + "properties": { + "delegation": { + "$ref": "#/definitions/v1beta1Delegation" + }, + "balance": { + "$ref": "#/definitions/v1beta1Coin" + } + }, + "description": "DelegationResponse is equivalent to Delegation except that it contains a balance\nin addition to shares which is more suitable for client responses." + }, + "v1beta1Description": { + "type": "object", + "properties": { + "moniker": { + "type": "string" + }, + "identity": { + "type": "string" + }, + "website": { + "type": "string" + }, + "security_contact": { + "type": "string" + }, + "details": { + "type": "string" + } + }, + "description": "Description defines a validator description." + }, + "v1beta1HistoricalInfo": { + "type": "object", + "properties": { + "header": { + "$ref": "#/definitions/typesHeader" + }, + "valset": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1Validator" + } + } + }, + "description": "HistoricalInfo contains the historical information that gets stored at\neach height." + }, + "v1beta1PageRequest": { + "type": "object", + "properties": { + "key": { + "type": "string", + "format": "byte", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." + }, + "offset": { + "type": "string", + "format": "uint64", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." + }, + "limit": { + "type": "string", + "format": "uint64", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." + }, + "count_total": { + "type": "boolean", + "format": "boolean", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." + } + }, + "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", + "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" + }, + "v1beta1PageResponse": { + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + }, + "v1beta1Params": { + "type": "object", + "properties": { + "unbonding_time": { + "type": "string" + }, + "max_validators": { + "type": "integer", + "format": "int64" + }, + "max_entries": { + "type": "integer", + "format": "int64" + }, + "historical_entries": { + "type": "integer", + "format": "int64" + }, + "bond_denom": { + "type": "string" + } + }, + "description": "Params defines the parameters for the staking module." + }, + "v1beta1Pool": { + "type": "object", + "properties": { + "not_bonded_tokens": { + "type": "string" + }, + "bonded_tokens": { + "type": "string" + } + }, + "title": "Pool - tracking bonded and not-bonded token supply of the bond denomination" + }, + "v1beta1QueryDelegationResponse": { + "type": "object", + "properties": { + "delegation_response": { + "$ref": "#/definitions/v1beta1DelegationResponse", + "description": "delegation_responses defines the delegation info of a delegation." + } + }, + "description": "QueryDelegationResponse is response type for the Query/Delegation RPC method." + }, + "v1beta1QueryDelegatorDelegationsResponse": { + "type": "object", + "properties": { + "delegation_responses": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1DelegationResponse" + }, + "description": "delegation_responses defines all the delegations' info of a delegator." + }, + "pagination": { + "$ref": "#/definitions/v1beta1PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryDelegatorDelegationsResponse is response type for the Query/DelegatorDelegations RPC method." + }, + "v1beta1QueryDelegatorUnbondingDelegationsResponse": { + "type": "object", + "properties": { + "unbonding_responses": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1UnbondingDelegation" + } + }, + "pagination": { + "$ref": "#/definitions/v1beta1PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryUnbondingDelegatorDelegationsResponse is response type for the Query/UnbondingDelegatorDelegations RPC method." + }, + "v1beta1QueryDelegatorValidatorResponse": { + "type": "object", + "properties": { + "validator": { + "$ref": "#/definitions/v1beta1Validator", + "description": "validator defines the the validator info." + } + }, + "description": "QueryDelegatorValidatorResponse response type for the Query/DelegatorValidator RPC method." + }, + "v1beta1QueryDelegatorValidatorsResponse": { + "type": "object", + "properties": { + "validators": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1Validator" + }, + "description": "validators defines the the validators' info of a delegator." + }, + "pagination": { + "$ref": "#/definitions/v1beta1PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryDelegatorValidatorsResponse is response type for the Query/DelegatorValidators RPC method." + }, + "v1beta1QueryHistoricalInfoResponse": { + "type": "object", + "properties": { + "hist": { + "$ref": "#/definitions/v1beta1HistoricalInfo", + "description": "hist defines the historical info at the given height." + } + }, + "description": "QueryHistoricalInfoResponse is response type for the Query/HistoricalInfo RPC method." + }, + "v1beta1QueryParamsResponse": { + "type": "object", + "properties": { + "params": { + "$ref": "#/definitions/v1beta1Params", + "description": "params holds all the parameters of this module." + } + }, + "description": "QueryParamsResponse is response type for the Query/Params RPC method." + }, + "v1beta1QueryPoolResponse": { + "type": "object", + "properties": { + "pool": { + "$ref": "#/definitions/v1beta1Pool", + "description": "pool defines the pool info." + } + }, + "description": "QueryPoolResponse is response type for the Query/Pool RPC method." + }, + "v1beta1QueryRedelegationsResponse": { + "type": "object", + "properties": { + "redelegation_responses": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1RedelegationResponse" + } + }, + "pagination": { + "$ref": "#/definitions/v1beta1PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryRedelegationsResponse is response type for the Query/Redelegations RPC method." + }, + "v1beta1QueryUnbondingDelegationResponse": { + "type": "object", + "properties": { + "unbond": { + "$ref": "#/definitions/v1beta1UnbondingDelegation", + "description": "unbond defines the unbonding information of a delegation." + } + }, + "description": "QueryDelegationResponse is response type for the Query/UnbondingDelegation RPC method." + }, + "v1beta1QueryValidatorDelegationsResponse": { + "type": "object", + "properties": { + "delegation_responses": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1DelegationResponse" + } + }, + "pagination": { + "$ref": "#/definitions/v1beta1PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "title": "QueryValidatorDelegationsResponse is response type for the Query/ValidatorDelegations RPC method" + }, + "v1beta1QueryValidatorResponse": { + "type": "object", + "properties": { + "validator": { + "$ref": "#/definitions/v1beta1Validator", + "description": "validator defines the the validator info." + } + }, + "title": "QueryValidatorResponse is response type for the Query/Validator RPC method" + }, + "v1beta1QueryValidatorUnbondingDelegationsResponse": { + "type": "object", + "properties": { + "unbonding_responses": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1UnbondingDelegation" + } + }, + "pagination": { + "$ref": "#/definitions/v1beta1PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryValidatorUnbondingDelegationsResponse is response type for the Query/ValidatorUnbondingDelegations RPC method." + }, + "v1beta1QueryValidatorsResponse": { + "type": "object", + "properties": { + "validators": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1Validator" + }, + "description": "validators contains all the queried validators." + }, + "pagination": { + "$ref": "#/definitions/v1beta1PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "title": "QueryValidatorsResponse is response type for the Query/Validators RPC method" + }, + "v1beta1Redelegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_src_address": { + "type": "string", + "format": "byte" + }, + "validator_dst_address": { + "type": "string", + "format": "byte" + }, + "entries": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1RedelegationEntry" + } + } + }, + "description": "Redelegation contains the list of a particular delegator's redelegating bonds\nfrom a particular source validator to a particular destination validator." + }, + "v1beta1RedelegationEntry": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "shares_dst": { + "type": "string" + } + }, + "description": "RedelegationEntry defines a redelegation object with relevant metadata." + }, + "v1beta1RedelegationEntryResponse": { + "type": "object", + "properties": { + "redelegation_entry": { + "$ref": "#/definitions/v1beta1RedelegationEntry" + }, + "balance": { + "type": "string" + } + }, + "description": "RedelegationEntryResponse is equivalent to a RedelegationEntry except that it\ncontains a balance in addition to shares which is more suitable for client\nresponses." + }, + "v1beta1RedelegationResponse": { + "type": "object", + "properties": { + "redelegation": { + "$ref": "#/definitions/v1beta1Redelegation" + }, + "entries": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1RedelegationEntryResponse" + } + } + }, + "description": "RedelegationResponse is equivalent to a Redelegation except that its entries\ncontain a balance in addition to shares which is more suitable for client\nresponses." + }, + "v1beta1UnbondingDelegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "entries": { + "type": "array", + "items": { + "$ref": "#/definitions/v1beta1UnbondingDelegationEntry" + } + } + }, + "title": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list" + }, + "v1beta1UnbondingDelegationEntry": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "balance": { + "type": "string" + } + }, + "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." + }, + "v1beta1Validator": { + "type": "object", + "properties": { + "operator_address": { + "type": "string", + "format": "byte" + }, + "consensus_pubkey": { + "type": "string" + }, + "jailed": { + "type": "boolean", + "format": "boolean" + }, + "status": { + "type": "integer", + "format": "int32" + }, + "tokens": { + "type": "string" + }, + "delegator_shares": { + "type": "string" + }, + "description": { + "$ref": "#/definitions/v1beta1Description" + }, + "unbonding_height": { + "type": "string", + "format": "int64" + }, + "unbonding_time": { + "type": "string", + "format": "date-time" + }, + "commission": { + "$ref": "#/definitions/v1beta1Commission" + }, + "min_self_delegation": { + "type": "string" + } + }, + "description": "Validator defines the total amount of bond shares and their exchange rate to\ncoins. Slashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." + }, + "versionConsensus": { + "type": "object", + "properties": { + "block": { + "type": "string", + "format": "uint64" + }, + "app": { + "type": "string", + "format": "uint64" + } + }, + "description": "Consensus captures the consensus rules for processing a block in the blockchain,\nincluding all blockchain data structures and the rules of the application's\nstate transition machine." + } + } +} diff --git a/x/upgrade/v1beta1/query.swagger.json b/x/upgrade/v1beta1/query.swagger.json new file mode 100644 index 000000000000..1091f939b017 --- /dev/null +++ b/x/upgrade/v1beta1/query.swagger.json @@ -0,0 +1,150 @@ +{ + "swagger": "2.0", + "info": { + "title": "cosmos/upgrade/v1beta1/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/cosmos/upgrade/v1beta1/applied_plan/{name}": { + "get": { + "summary": "AppliedPlan queries a previously applied upgrade plan by its name.", + "operationId": "Query_AppliedPlan", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryAppliedPlanResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "parameters": [ + { + "name": "name", + "description": "name is the name of the applied plan to query for.", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/upgrade/v1beta1/current_plan": { + "get": { + "summary": "CurrentPlan queries the current upgrade plan.", + "operationId": "Query_CurrentPlan", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1beta1QueryCurrentPlanResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/runtimeError" + } + } + }, + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "protobufAny": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + }, + "runtimeError": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/protobufAny" + } + } + } + }, + "v1beta1Plan": { + "type": "object", + "properties": { + "name": { + "type": "string", + "description": "Sets the name for the upgrade. This name will be used by the upgraded version of the software to apply any\nspecial \"on-upgrade\" commands during the first BeginBlock method after the upgrade is applied. It is also used\nto detect whether a software version can handle a given upgrade. If no upgrade handler with this name has been\nset in the software, it will be assumed that the software is out-of-date when the upgrade Time or Height\nis reached and the software will exit." + }, + "time": { + "type": "string", + "format": "date-time", + "description": "The time after which the upgrade must be performed.\nLeave set to its zero value to use a pre-defined Height instead." + }, + "height": { + "type": "string", + "format": "int64", + "description": "The height at which the upgrade must be performed.\nOnly used if Time is not set." + }, + "info": { + "type": "string", + "title": "Any application specific upgrade info to be included on-chain\nsuch as a git commit that validators could automatically upgrade to" + } + }, + "title": "Plan specifies information about a planned upgrade and when it should occur" + }, + "v1beta1QueryAppliedPlanResponse": { + "type": "object", + "properties": { + "height": { + "type": "string", + "format": "int64", + "description": "height is the block height at which the plan was applied." + } + }, + "description": "QueryAppliedPlanResponse is the response type for the Query/AppliedPlan RPC method." + }, + "v1beta1QueryCurrentPlanResponse": { + "type": "object", + "properties": { + "plan": { + "$ref": "#/definitions/v1beta1Plan", + "description": "plan is the current upgrade plan." + } + }, + "description": "QueryCurrentPlanResponse is the response type for the Query/CurrentPlan RPC method." + } + } +} From 355fb1c9a80b534ef3f51e0b3510b2e142c6e7a5 Mon Sep 17 00:00:00 2001 From: anilCSE Date: Thu, 20 Aug 2020 23:52:29 +0530 Subject: [PATCH 04/27] Remove loop --- scripts/protocgen.sh | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/scripts/protocgen.sh b/scripts/protocgen.sh index 377bdb7d633e..bd53db1113d3 100755 --- a/scripts/protocgen.sh +++ b/scripts/protocgen.sh @@ -20,11 +20,6 @@ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. \ --grpc-gateway_out=logtostderr=true:. \ $(find "${dir}" -maxdepth 1 -name '*.proto') - proto_files=${proto_files}" ${dir:2}/*.proto" -done - -proto_dirs=$(find ./proto -path -prune -o -name '*.proto' -print0 | xargs -0 -n1 dirname | sort | uniq) -for dir in $proto_dirs; do query_file=$(find "${dir}" -maxdepth 1 -name 'query.proto') if [[ ! -z "$query_file" ]]; then protoc \ @@ -33,6 +28,8 @@ for dir in $proto_dirs; do "$query_file" \ --swagger_out=logtostderr=true:. fi + + proto_files=${proto_files}" ${dir:2}/*.proto" done # generate codec/testdata proto code @@ -46,5 +43,3 @@ cp -r ibc/* ./x/ibc/ rm -rf github.com rm -rf cosmos rm -rf ibc - - From 60de7ac0f78c1b6e1b941a6939e77631dab891d8 Mon Sep 17 00:00:00 2001 From: anilCSE Date: Fri, 21 Aug 2020 00:11:43 +0530 Subject: [PATCH 05/27] Add go-swagger installation --- contrib/devtools/Makefile | 8 +- go.mod | 2 +- go.sum | 171 +++++ x/staking/types/staking.pb.go | 1123 ++++++++++++++++----------------- 4 files changed, 740 insertions(+), 564 deletions(-) diff --git a/contrib/devtools/Makefile b/contrib/devtools/Makefile index d9b73a654942..a89e75512758 100644 --- a/contrib/devtools/Makefile +++ b/contrib/devtools/Makefile @@ -99,7 +99,13 @@ proto-tools-stamp: @go install github.com/regen-network/cosmos-proto/protoc-gen-gocosmos @echo "Installing protoc-gen-grpc-gateway..." - @go install https://github.com/grpc-ecosystem/grpc-gateway/protoc-gen-grpc-gateway + @go install github.com/grpc-ecosystem/grpc-gateway/protoc-gen-grpc-gateway + + @echo "Installing go-swagger..." + @(download_url=$(curl -s https://api.github.com/repos/go-swagger/go-swagger/releases/latest | \ + jq -r '.assets[] | select(.name | contains("'"$(uname | tr '[:upper:]' '[:lower:]')"'_amd64")) | .browser_download_url') \ + curl -o /usr/local/bin/swagger -L'#' "$download_url" \ + chmod +x /usr/local/bin/swagger) touch $@ diff --git a/go.mod b/go.mod index 90602dbee6db..13b736b00549 100644 --- a/go.mod +++ b/go.mod @@ -12,6 +12,7 @@ require ( github.com/cosmos/iavl v0.15.0-rc1 github.com/cosmos/ledger-cosmos-go v0.11.1 github.com/enigmampc/btcutil v1.0.3-0.20200723161021-e2fb6adb2a25 + github.com/go-swagger/go-swagger v0.25.0 // indirect github.com/gogo/protobuf v1.3.1 github.com/golang/mock v1.4.4 github.com/golang/protobuf v1.4.2 @@ -27,7 +28,6 @@ require ( github.com/prometheus/common v0.12.0 github.com/rakyll/statik v0.1.7 github.com/regen-network/cosmos-proto v0.3.0 - github.com/spf13/afero v1.2.2 // indirect github.com/spf13/cast v1.3.1 github.com/spf13/cobra v1.0.0 github.com/spf13/jwalterweatherman v1.1.0 // indirect; indirects diff --git a/go.sum b/go.sum index 95c4fc39b085..db2c89a1647a 100644 --- a/go.sum +++ b/go.sum @@ -24,6 +24,9 @@ github.com/DataDog/zstd v1.4.1/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0= github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE= github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= +github.com/PuerkitoBio/purell v1.1.0/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0= +github.com/PuerkitoBio/purell v1.1.1/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0= +github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE= github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo= github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI= github.com/VividCortex/gohistogram v1.0.0 h1:6+hBz+qvs0JOrrNhhmR7lFxo5sINxBCGXrdtl/UvroE= @@ -48,6 +51,10 @@ github.com/armon/go-metrics v0.3.4 h1:Xqf+7f2Vhl9tsqDYmXhnXInUdcrtgpRNpIA15/uldS github.com/armon/go-metrics v0.3.4/go.mod h1:4O98XIr/9W0sxpJ8UaYkvjk10Iff7SnFrb4QAOwNTFc= github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= github.com/aryann/difflib v0.0.0-20170710044230-e206f873d14a/go.mod h1:DAHtR1m6lCRdSC2Tm3DSWRPvIPr6xNKyeHdqDQSQT+A= +github.com/asaskevich/govalidator v0.0.0-20180720115003-f9ffefc3facf/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY= +github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY= +github.com/asaskevich/govalidator v0.0.0-20200108200545-475eaeb16496/go.mod h1:oGkLhpf+kjZl6xBf758TQhh5XrAeiJv/7FRz/2spLIg= +github.com/asaskevich/govalidator v0.0.0-20200428143746-21a406dcc535/go.mod h1:oGkLhpf+kjZl6xBf758TQhh5XrAeiJv/7FRz/2spLIg= github.com/aws/aws-lambda-go v1.13.3/go.mod h1:4UKl9IzQMoD+QF79YdCuzCwp8VbmG4VAQwij/eHl5CU= github.com/aws/aws-sdk-go v1.27.0/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo= github.com/aws/aws-sdk-go-v2 v0.18.0/go.mod h1:JWVYvqSMppoMJC0x5wdwiImzgXTI9FuZwxzkQq9wy+g= @@ -93,6 +100,7 @@ github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkE github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE= github.com/coreos/etcd v3.3.13+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE= github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk= +github.com/coreos/go-oidc v2.2.1+incompatible/go.mod h1:CgnwVTmzoESiwO9qyAFEMiHoZ1nMCKZlZ9V6mm3/LKc= github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= github.com/coreos/go-systemd v0.0.0-20180511133405-39ca1b05acc7/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4= @@ -111,6 +119,7 @@ github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwc github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY= +github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/danieljoos/wincred v1.0.2 h1:zf4bhty2iLuwgjgpraD2E9UbvO+fe54XXGJbOwe23fU= github.com/danieljoos/wincred v1.0.2/go.mod h1:SnuYRW9lp1oJrZX/dXJqr0cPK5gYXqx3EJbmjhLdK9U= github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= @@ -125,6 +134,8 @@ github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZm github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 h1:tdlZCpZ/P9DhczCTSixgIKmwPv6+wP5DGjqLYw5SUiA= github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no= +github.com/docker/go-units v0.3.3/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= +github.com/docker/go-units v0.4.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo= github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= @@ -154,8 +165,11 @@ github.com/franela/goblin v0.0.0-20200105215937-c9ffbefa60db/go.mod h1:7dvUGVsVB github.com/franela/goreq v0.0.0-20171204163338-bcd34c9993f8/go.mod h1:ZhphrRTfi2rbfLwlschooIH4+wKKDR4Pdxhh+TRoA20= github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I= github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= +github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= +github.com/globalsign/mgo v0.0.0-20180905125535-1ca0a4f7cbcb/go.mod h1:xkRDCp4j0OGD1HRkm4kmhM+pmpv3AKq5SU7GMg4oO/Q= +github.com/globalsign/mgo v0.0.0-20181015135952-eeefdecb41b8/go.mod h1:xkRDCp4j0OGD1HRkm4kmhM+pmpv3AKq5SU7GMg4oO/Q= github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= @@ -165,9 +179,92 @@ github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= github.com/go-logfmt/logfmt v0.5.0 h1:TrB8swr/68K7m9CcGut2g3UOihhbcbiMAYiuTXdEih4= github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A= +github.com/go-openapi/analysis v0.0.0-20180825180245-b006789cd277/go.mod h1:k70tL6pCuVxPJOHXQ+wIac1FUrvNkHolPie/cLEU6hI= +github.com/go-openapi/analysis v0.17.0/go.mod h1:IowGgpVeD0vNm45So8nr+IcQ3pxVtpRoBWb8PVZO0ik= +github.com/go-openapi/analysis v0.18.0/go.mod h1:IowGgpVeD0vNm45So8nr+IcQ3pxVtpRoBWb8PVZO0ik= +github.com/go-openapi/analysis v0.19.2/go.mod h1:3P1osvZa9jKjb8ed2TPng3f0i/UY9snX6gxi44djMjk= +github.com/go-openapi/analysis v0.19.4/go.mod h1:3P1osvZa9jKjb8ed2TPng3f0i/UY9snX6gxi44djMjk= +github.com/go-openapi/analysis v0.19.5/go.mod h1:hkEAkxagaIvIP7VTn8ygJNkd4kAYON2rCu0v0ObL0AU= +github.com/go-openapi/analysis v0.19.10/go.mod h1:qmhS3VNFxBlquFJ0RGoDtylO9y4pgTAUNE9AEEMdlJQ= +github.com/go-openapi/errors v0.17.0/go.mod h1:LcZQpmvG4wyF5j4IhA73wkLFQg+QJXOQHVjmcZxhka0= +github.com/go-openapi/errors v0.18.0/go.mod h1:LcZQpmvG4wyF5j4IhA73wkLFQg+QJXOQHVjmcZxhka0= +github.com/go-openapi/errors v0.19.2/go.mod h1:qX0BLWsyaKfvhluLejVpVNwNRdXZhEbTA4kxxpKBC94= +github.com/go-openapi/errors v0.19.3/go.mod h1:qX0BLWsyaKfvhluLejVpVNwNRdXZhEbTA4kxxpKBC94= +github.com/go-openapi/errors v0.19.6/go.mod h1:cM//ZKUKyO06HSwqAelJ5NsEMMcpa6VpXe8DOa1Mi1M= +github.com/go-openapi/inflect v0.19.0/go.mod h1:lHpZVlpIQqLyKwJ4N+YSc9hchQy/i12fJykb83CRBH4= +github.com/go-openapi/jsonpointer v0.17.0/go.mod h1:cOnomiV+CVVwFLk0A/MExoFMjwdsUdVpsRhURCKh+3M= +github.com/go-openapi/jsonpointer v0.18.0/go.mod h1:cOnomiV+CVVwFLk0A/MExoFMjwdsUdVpsRhURCKh+3M= +github.com/go-openapi/jsonpointer v0.19.2/go.mod h1:3akKfEdA7DF1sugOqz1dVQHBcuDBPKZGEoHC/NkiQRg= +github.com/go-openapi/jsonpointer v0.19.3/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg= +github.com/go-openapi/jsonreference v0.17.0/go.mod h1:g4xxGn04lDIRh0GJb5QlpE3HfopLOL6uZrK/VgnsK9I= +github.com/go-openapi/jsonreference v0.18.0/go.mod h1:g4xxGn04lDIRh0GJb5QlpE3HfopLOL6uZrK/VgnsK9I= +github.com/go-openapi/jsonreference v0.19.2/go.mod h1:jMjeRr2HHw6nAVajTXJ4eiUwohSTlpa0o73RUL1owJc= +github.com/go-openapi/jsonreference v0.19.3/go.mod h1:rjx6GuL8TTa9VaixXglHmQmIL98+wF9xc8zWvFonSJ8= +github.com/go-openapi/jsonreference v0.19.4/go.mod h1:RdybgQwPxbL4UEjuAruzK1x3nE69AqPYEJeo/TWfEeg= +github.com/go-openapi/loads v0.17.0/go.mod h1:72tmFy5wsWx89uEVddd0RjRWPZm92WRLhf7AC+0+OOU= +github.com/go-openapi/loads v0.18.0/go.mod h1:72tmFy5wsWx89uEVddd0RjRWPZm92WRLhf7AC+0+OOU= +github.com/go-openapi/loads v0.19.0/go.mod h1:72tmFy5wsWx89uEVddd0RjRWPZm92WRLhf7AC+0+OOU= +github.com/go-openapi/loads v0.19.2/go.mod h1:QAskZPMX5V0C2gvfkGZzJlINuP7Hx/4+ix5jWFxsNPs= +github.com/go-openapi/loads v0.19.3/go.mod h1:YVfqhUCdahYwR3f3iiwQLhicVRvLlU/WO5WPaZvcvSI= +github.com/go-openapi/loads v0.19.5/go.mod h1:dswLCAdonkRufe/gSUC3gN8nTSaB9uaS2es0x5/IbjY= +github.com/go-openapi/runtime v0.0.0-20180920151709-4f900dc2ade9/go.mod h1:6v9a6LTXWQCdL8k1AO3cvqx5OtZY/Y9wKTgaoP6YRfA= +github.com/go-openapi/runtime v0.19.0/go.mod h1:OwNfisksmmaZse4+gpV3Ne9AyMOlP1lt4sK4FXt0O64= +github.com/go-openapi/runtime v0.19.4/go.mod h1:X277bwSUBxVlCYR3r7xgZZGKVvBd/29gLDlFGtJ8NL4= +github.com/go-openapi/runtime v0.19.15/go.mod h1:dhGWCTKRXlAfGnQG0ONViOZpjfg0m2gUt9nTQPQZuoo= +github.com/go-openapi/runtime v0.19.20/go.mod h1:Lm9YGCeecBnUUkFTxPC4s1+lwrkJ0pthx8YvyjCfkgk= +github.com/go-openapi/spec v0.17.0/go.mod h1:XkF/MOi14NmjsfZ8VtAKf8pIlbZzyoTvZsdfssdxcBI= +github.com/go-openapi/spec v0.18.0/go.mod h1:XkF/MOi14NmjsfZ8VtAKf8pIlbZzyoTvZsdfssdxcBI= +github.com/go-openapi/spec v0.19.2/go.mod h1:sCxk3jxKgioEJikev4fgkNmwS+3kuYdJtcsZsD5zxMY= +github.com/go-openapi/spec v0.19.3/go.mod h1:FpwSN1ksY1eteniUU7X0N/BgJ7a4WvBFVA8Lj9mJglo= +github.com/go-openapi/spec v0.19.6/go.mod h1:Hm2Jr4jv8G1ciIAo+frC/Ft+rR2kQDh8JHKHb3gWUSk= +github.com/go-openapi/spec v0.19.8/go.mod h1:Hm2Jr4jv8G1ciIAo+frC/Ft+rR2kQDh8JHKHb3gWUSk= +github.com/go-openapi/strfmt v0.17.0/go.mod h1:P82hnJI0CXkErkXi8IKjPbNBM6lV6+5pLP5l494TcyU= +github.com/go-openapi/strfmt v0.18.0/go.mod h1:P82hnJI0CXkErkXi8IKjPbNBM6lV6+5pLP5l494TcyU= +github.com/go-openapi/strfmt v0.19.0/go.mod h1:+uW+93UVvGGq2qGaZxdDeJqSAqBqBdl+ZPMF/cC8nDY= +github.com/go-openapi/strfmt v0.19.2/go.mod h1:0yX7dbo8mKIvc3XSKp7MNfxw4JytCfCD6+bY1AVL9LU= +github.com/go-openapi/strfmt v0.19.3/go.mod h1:0yX7dbo8mKIvc3XSKp7MNfxw4JytCfCD6+bY1AVL9LU= +github.com/go-openapi/strfmt v0.19.4/go.mod h1:eftuHTlB/dI8Uq8JJOyRlieZf+WkkxUuk0dgdHXr2Qk= +github.com/go-openapi/strfmt v0.19.5/go.mod h1:eftuHTlB/dI8Uq8JJOyRlieZf+WkkxUuk0dgdHXr2Qk= +github.com/go-openapi/swag v0.17.0/go.mod h1:AByQ+nYG6gQg71GINrmuDXCPWdL640yX49/kXLo40Tg= +github.com/go-openapi/swag v0.18.0/go.mod h1:AByQ+nYG6gQg71GINrmuDXCPWdL640yX49/kXLo40Tg= +github.com/go-openapi/swag v0.19.2/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk= +github.com/go-openapi/swag v0.19.5/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk= +github.com/go-openapi/swag v0.19.7/go.mod h1:ao+8BpOPyKdpQz3AOJfbeEVpLmWAvlT1IfTe5McPyhY= +github.com/go-openapi/swag v0.19.9/go.mod h1:ao+8BpOPyKdpQz3AOJfbeEVpLmWAvlT1IfTe5McPyhY= +github.com/go-openapi/validate v0.18.0/go.mod h1:Uh4HdOzKt19xGIGm1qHf/ofbX1YQ4Y+MYsct2VUrAJ4= +github.com/go-openapi/validate v0.19.2/go.mod h1:1tRCw7m3jtI8eNWEEliiAqUIcBztB2KDnRCRMUi7GTA= +github.com/go-openapi/validate v0.19.3/go.mod h1:90Vh6jjkTn+OT1Eefm0ZixWNFjhtOH7vS9k0lo6zwJo= +github.com/go-openapi/validate v0.19.10/go.mod h1:RKEZTUWDkxKQxN2jDT7ZnZi2bhZlbNMAuKvKB+IaGx8= github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w= github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk= github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= +github.com/go-swagger/go-swagger v0.25.0 h1:FxhyrWWV8V/A9P6GtI5szWordAdbb6Y0nqdY/y9So2w= +github.com/go-swagger/go-swagger v0.25.0/go.mod h1:9639ioXrPX9E6BbnbaDklGXjNz7upAXoNBwL4Ok11Vk= +github.com/go-swagger/scan-repo-boundary v0.0.0-20180623220736-973b3573c013/go.mod h1:b65mBPzqzZWxOZGxSWrqs4GInLIn+u99Q9q7p+GKni0= +github.com/gobuffalo/attrs v0.0.0-20190224210810-a9411de4debd/go.mod h1:4duuawTqi2wkkpB4ePgWMaai6/Kc6WEz83bhFwpHzj0= +github.com/gobuffalo/depgen v0.0.0-20190329151759-d478694a28d3/go.mod h1:3STtPUQYuzV0gBVOY3vy6CfMm/ljR4pABfrTeHNLHUY= +github.com/gobuffalo/depgen v0.1.0/go.mod h1:+ifsuy7fhi15RWncXQQKjWS9JPkdah5sZvtHc2RXGlg= +github.com/gobuffalo/envy v1.6.15/go.mod h1:n7DRkBerg/aorDM8kbduw5dN3oXGswK5liaSCx4T5NI= +github.com/gobuffalo/envy v1.7.0/go.mod h1:n7DRkBerg/aorDM8kbduw5dN3oXGswK5liaSCx4T5NI= +github.com/gobuffalo/flect v0.1.0/go.mod h1:d2ehjJqGOH/Kjqcoz+F7jHTBbmDb38yXA598Hb50EGs= +github.com/gobuffalo/flect v0.1.1/go.mod h1:8JCgGVbRjJhVgD6399mQr4fx5rRfGKVzFjbj6RE/9UI= +github.com/gobuffalo/flect v0.1.3/go.mod h1:8JCgGVbRjJhVgD6399mQr4fx5rRfGKVzFjbj6RE/9UI= +github.com/gobuffalo/genny v0.0.0-20190329151137-27723ad26ef9/go.mod h1:rWs4Z12d1Zbf19rlsn0nurr75KqhYp52EAGGxTbBhNk= +github.com/gobuffalo/genny v0.0.0-20190403191548-3ca520ef0d9e/go.mod h1:80lIj3kVJWwOrXWWMRzzdhW3DsrdjILVil/SFKBzF28= +github.com/gobuffalo/genny v0.1.0/go.mod h1:XidbUqzak3lHdS//TPu2OgiFB+51Ur5f7CSnXZ/JDvo= +github.com/gobuffalo/genny v0.1.1/go.mod h1:5TExbEyY48pfunL4QSXxlDOmdsD44RRq4mVZ0Ex28Xk= +github.com/gobuffalo/gitgen v0.0.0-20190315122116-cc086187d211/go.mod h1:vEHJk/E9DmhejeLeNt7UVvlSGv3ziL+djtTr3yyzcOw= +github.com/gobuffalo/gogen v0.0.0-20190315121717-8f38393713f5/go.mod h1:V9QVDIxsgKNZs6L2IYiGR8datgMhB577vzTDqypH360= +github.com/gobuffalo/gogen v0.1.0/go.mod h1:8NTelM5qd8RZ15VjQTFkAW6qOMx5wBbW4dSCS3BY8gg= +github.com/gobuffalo/gogen v0.1.1/go.mod h1:y8iBtmHmGc4qa3urIyo1shvOD8JftTtfcKi+71xfDNE= +github.com/gobuffalo/logger v0.0.0-20190315122211-86e12af44bc2/go.mod h1:QdxcLw541hSGtBnhUc4gaNIXRjiDppFGaDqzbrBd3v8= +github.com/gobuffalo/mapi v1.0.1/go.mod h1:4VAGh89y6rVOvm5A8fKFxYG+wIW6LO1FMTG9hnKStFc= +github.com/gobuffalo/mapi v1.0.2/go.mod h1:4VAGh89y6rVOvm5A8fKFxYG+wIW6LO1FMTG9hnKStFc= +github.com/gobuffalo/packd v0.0.0-20190315124812-a385830c7fc0/go.mod h1:M2Juc+hhDXf/PnmBANFCqx4DM3wRbgDvnVWeG2RIxq4= +github.com/gobuffalo/packd v0.1.0/go.mod h1:M2Juc+hhDXf/PnmBANFCqx4DM3wRbgDvnVWeG2RIxq4= +github.com/gobuffalo/packr/v2 v2.0.9/go.mod h1:emmyGweYTm6Kdper+iywB6YK5YzuKchGtJQZ0Odn4pQ= +github.com/gobuffalo/packr/v2 v2.2.0/go.mod h1:CaAwI0GPIAv+5wKLtv8Afwl+Cm78K/I/VCm/3ptBN+0= +github.com/gobuffalo/syncx v0.0.0-20190224160051-33c29581e754/go.mod h1:HhnNqWY95UYwwW3uSASeV7vtgYkT2t16hJgV3AEPUpw= github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2 h1:ZpnhV/YsD2/4cESfV5+Hoeu/iUR3ruzNvZ+yQfO03a0= github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2/go.mod h1:bBOAhwG1umN6/6ZUMtDFBMQR8jRg9O75tm9K00oMsK4= github.com/gogo/googleapis v1.1.0/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s= @@ -217,6 +314,7 @@ github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OI github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1 h1:EGx4pi6eqNxGaHF6qqu48+N2wcFQ5qg5FXgOdqsJ5d8= @@ -285,9 +383,11 @@ github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NH github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= github.com/influxdata/influxdb1-client v0.0.0-20191209144304-8bf82d3c094d/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo= github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= +github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k= github.com/jmhodges/levigo v1.0.0 h1:q5EC36kV79HWeTBWsod3mG11EgStG3qArTKcvlksN1U= github.com/jmhodges/levigo v1.0.0/go.mod h1:Q6Qx+uH3RAqyK4rFQroq9RL7mdkABMcfhEI+nNuzMJQ= +github.com/joho/godotenv v1.3.0/go.mod h1:7hK45KPybAkOC6peb+G5yklZfMxEjkZhHbwpqxOKXbg= github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo= github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4= github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ= @@ -301,19 +401,27 @@ github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM= +github.com/karrick/godirwalk v1.8.0/go.mod h1:H5KPZjojv4lE+QYImBI8xVtrBRgYrIVsaRPx4tDPEn4= +github.com/karrick/godirwalk v1.10.3/go.mod h1:RoGL9dQei4vP9ilrpETWE8CLOZ1kiN0LhBygSwrAsHA= github.com/keybase/go-keychain v0.0.0-20190712205309-48d3d31d256d h1:Z+RDyXzjKE0i2sTjZ/b1uxiGtPhFy34Ou/Tk0qwN0kM= github.com/keybase/go-keychain v0.0.0-20190712205309-48d3d31d256d/go.mod h1:JJNrCn9otv/2QP4D7SMJBgaleKpOf66PnW6F5WGNRIc= github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4= github.com/kkdai/bstream v1.0.0/go.mod h1:FDnDOHt5Yx4p3FaHcioFT0QjDOtgUpvjeZqAs+NVZZA= +github.com/klauspost/compress v1.9.5/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= +github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= +github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/pty v1.1.5/go.mod h1:9r2w37qlBe7rQ6e1fg1S/9xpWHSnaqNdHD3WcMdbPDA= github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/libp2p/go-buffer-pool v0.0.2 h1:QNK2iAFa8gjAe1SPz6mHSMuCcjs+X1wlHzeOSqcmlfs= github.com/libp2p/go-buffer-pool v0.0.2/go.mod h1:MvaB6xw5vOrDl8rYZGLFdKAuk/hRoRZd1Vi32+RXyFM= github.com/lightstep/lightstep-tracer-common/golang/gogo v0.0.0-20190605223551-bc2310a04743/go.mod h1:qklhhLq1aX+mtWk9cPHPzaBjWImj5ULL6C7HFJtXQMM= @@ -322,6 +430,13 @@ github.com/lyft/protoc-gen-validate v0.0.13/go.mod h1:XbGvPuh87YZc5TdIa2/I4pLk0Q github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= github.com/magiconair/properties v1.8.1 h1:ZC2Vc7/ZFkGmsVC9KvOjumD+G5lXy2RtTKyzRKO2BQ4= github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= +github.com/mailru/easyjson v0.0.0-20180823135443-60711f1a8329/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= +github.com/mailru/easyjson v0.0.0-20190312143242-1de009706dbe/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= +github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= +github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= +github.com/mailru/easyjson v0.7.1/go.mod h1:KAzv3t3aY1NaHWoQz1+4F1ccyAH66Jk7yos7ldAVICs= +github.com/markbates/oncer v0.0.0-20181203154359-bf2de49a0be2/go.mod h1:Ld9puTsIW75CHf65OeIOkyKbteujpZVXDpWK6YGZbxE= +github.com/markbates/safe v1.0.1/go.mod h1:nAqgmRi7cY2nqMc92/bSEeQA+R4OheNU2T1kNSCBdG0= github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= @@ -345,10 +460,12 @@ github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0Qu github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE= github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= +github.com/mitchellh/mapstructure v1.3.2/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc= github.com/mtibben/percent v0.2.1 h1:5gssi8Nqo8QU/r2pynCm+hBQHpkB/uNK7BJCFogWdzs= github.com/mtibben/percent v0.2.1/go.mod h1:KG9uO+SZkUp+VkRHsCdYQV3XSZrrSpR3O9ibNBTZrns= github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= @@ -394,6 +511,7 @@ github.com/pascaldekloe/goe v0.1.0 h1:cBOtyMzM9HTpWjXfbbunk26uA6nG3a8n06Wieeh0Mw github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc= github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k= github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic= +github.com/pelletier/go-toml v1.4.0/go.mod h1:PN7xzY2wHTK0K9p34ErDQMlFxa51Fk0OUruD3k1mMwo= github.com/pelletier/go-toml v1.8.0 h1:Keo9qb7iRJs2voHvunFtuuYFsbWeOBh8/P9v/kVMFtw= github.com/pelletier/go-toml v1.8.0/go.mod h1:D6yutnOGMveHEPV7VQOuvI/gXY61bv+9bAOTRnLElKs= github.com/performancecopilot/speed v3.0.0+incompatible/go.mod h1:/CLtqpZ5gBg1M9iaPbIdPPGyKcA8hKdoy6hAWba7Yac= @@ -406,9 +524,11 @@ github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINE github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/profile v1.2.1/go.mod h1:hJw3o1OdXxsrSjjVksARp5W95eeEaEfptyVZyv6JUPA= +github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI= +github.com/pquerna/cachecontrol v0.0.0-20180517163645-1555304b9b35/go.mod h1:prYjPmNq4d1NPVmpShWobRqXY3q7Vp+80DqgxxUrUIA= github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod h1:p2iRAGwDERtqlqzRXnrOVns+ignqQo//hLXqYxZYVNs= github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso= @@ -455,6 +575,8 @@ github.com/regen-network/protobuf v1.3.2-alpha.regen.4 h1:c9jEnU+xm6vqyrQe3M94UF github.com/regen-network/protobuf v1.3.2-alpha.regen.4/go.mod h1:/J8/bR1T/NXyIdQDLUaq15LjNE83nRzkyrLAMcPewig= github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg= github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= +github.com/rogpeppe/go-internal v1.1.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= +github.com/rogpeppe/go-internal v1.2.2/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik= github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= @@ -467,6 +589,8 @@ github.com/sasha-s/go-deadlock v0.2.0/go.mod h1:StQn567HiB1fF2yJ44N9au7wOhrPS3iZ github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc= github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= +github.com/sirupsen/logrus v1.4.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= +github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q= github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88= github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM= @@ -482,6 +606,7 @@ github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2 github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ= github.com/spf13/afero v1.2.2 h1:5jhuqJyZCZf2JRofRvN/nIFgIWNzPa3/Vz8mYylgbWc= github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk= +github.com/spf13/afero v1.3.2/go.mod h1:5KUK8ByomD5Ti5Artl0RtHeI5pTF7MIDuXL3yY520V4= github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= github.com/spf13/cast v1.3.1 h1:nFm6S0SMdyzrzcmThSipiEubIDy8WEXKNZ0UOgiRpng= github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= @@ -532,15 +657,20 @@ github.com/tendermint/tm-db v0.6.0 h1:Us30k7H1UDcdqoSPhmP8ztAW/SWV6c6OfsfeCiboTC 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/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk= github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= +github.com/toqueteos/webbrowser v1.2.0/go.mod h1:XWoZq4cyp9WeUeak7w7LXRUQf1F1ATJMir8RTqb4ayM= github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM= github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc= github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0= github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA= github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= +github.com/xdg/scram v0.0.0-20180814205039-7eeb5667e42c/go.mod h1:lB8K/P019DLNhemzwFU4jHLhdvlE6uDZjXFejJXr49I= +github.com/xdg/stringprep v0.0.0-20180714160509-73f8eece6fdc/go.mod h1:Jhud4/sHMO4oL310DaZAKk9ZaJ08SJfe+sJh0HrGL1Y= github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU= github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q= +github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/zondax/hid v0.9.0 h1:eiT3P6vNxAEVxXMw66eZUAAnU2zD33JBkfG/EnfAKl8= github.com/zondax/hid v0.9.0/go.mod h1:l5wttcP0jwtdLjqjMMWFVEE7d1zO0jvSPA9OPZxWpEM= go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= @@ -548,6 +678,11 @@ go.etcd.io/bbolt v1.3.3/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= go.etcd.io/bbolt v1.3.5 h1:XAzx9gjCb0Rxj7EoqcClPD1d5ZBxZJk0jbuoPHenBt0= go.etcd.io/bbolt v1.3.5/go.mod h1:G5EMThwa9y8QZGBClrRx5EY+Yw9kAhnjy3bSjsnlVTQ= go.etcd.io/etcd v0.0.0-20191023171146-3cf2f69b5738/go.mod h1:dnLIgRNXwCJa5e+c6mIZCrds/GIG4ncV9HhK5PX7jPg= +go.mongodb.org/mongo-driver v1.0.3/go.mod h1:u7ryQJ+DOzQmeO7zB6MHyr8jkEQvC8vH7qLUO4lqsUM= +go.mongodb.org/mongo-driver v1.1.1/go.mod h1:u7ryQJ+DOzQmeO7zB6MHyr8jkEQvC8vH7qLUO4lqsUM= +go.mongodb.org/mongo-driver v1.3.0/go.mod h1:MSWZXKOynuguX+JSvwP8i+58jYCXxbia8HS3gZBapIE= +go.mongodb.org/mongo-driver v1.3.4/go.mod h1:MSWZXKOynuguX+JSvwP8i+58jYCXxbia8HS3gZBapIE= +go.mongodb.org/mongo-driver v1.3.5/go.mod h1:Ual6Gkco7ZGQw8wE1t4tLnvBsf6yVSM60qW6TgOeJ5c= go.opencensus.io v0.20.1/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk= go.opencensus.io v0.20.2/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk= go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= @@ -566,9 +701,15 @@ golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnf golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20190320223903-b7391e95e576/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20190422162423-af44ce270edf/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE= golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190530122614-20be4c3c3ed5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190617133340-57b3e21c3d56/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20191206172530-e9b2fee46413/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200115085410-6d4e4cb37c7d/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= @@ -595,9 +736,11 @@ golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCc golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY= golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181005035420-146acd28ed58/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -606,6 +749,7 @@ golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73r golang.org/x/net v0.0.0-20190125091013-d26f9f9a57f3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190320064053-1272bf9dcd53/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= @@ -614,11 +758,15 @@ golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20191002035440-2ec189313ef0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200602114024-627f9648deb9/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/net v0.0.0-20200625001655-4c5254603344 h1:vGXIOMxbNfDTk/aXCmfdLgkrSV+Z2tcbze+pEc3v5W4= golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -627,8 +775,10 @@ golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190412183630-56d357773e84/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -641,16 +791,22 @@ golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5h golang.org/x/sys v0.0.0-20190130150945-aca44879d564/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190321052220-f7bb7a8bee54/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190419153524-e8e3143a4f4a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190531175056-4c3a928424d2/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190616124812-15dcb6c0061f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190712062909-fae7ac547cb7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191220142924-d4481acd189f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -666,6 +822,7 @@ golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= @@ -679,10 +836,16 @@ golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3 golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190329151228-23e29df326fe/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190416151739-9c9e1878f421/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190420181800-aa740d480789/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190531172133-b3315ee88b7d/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190614205625-5aca471b1d59/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190617190820-da514acc4774/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= @@ -691,8 +854,10 @@ golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtn golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191112195655-aa38f8e97acc/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200110213125-a7a6caa82ab2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200717024301-6ddee64345a6/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= @@ -708,6 +873,7 @@ google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= +google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20180831171423-11092d34479b/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= @@ -764,7 +930,9 @@ gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMy gopkg.in/gcfg.v1 v1.2.3/go.mod h1:yesOnuUOFQAhST5vPY4nbZsb/huCgGGXlipJsBn0b3o= gopkg.in/ini.v1 v1.51.0 h1:AQvPpx3LzTDM0AjnIRlVFwFFGC+npRopjZxLJj6gdno= gopkg.in/ini.v1 v1.51.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= +gopkg.in/ini.v1 v1.57.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo= +gopkg.in/square/go-jose.v2 v2.5.1/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76mk0e1AI= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI= @@ -774,10 +942,13 @@ gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU= gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.0-20200605160147-a5ece683394c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= diff --git a/x/staking/types/staking.pb.go b/x/staking/types/staking.pb.go index bf8668615614..caf4e73f7bb5 100644 --- a/x/staking/types/staking.pb.go +++ b/x/staking/types/staking.pb.go @@ -1263,571 +1263,570 @@ func (this *Pool) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_ func StakingDescription() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) { d := &github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet{} var gzipped = []byte{ - // 9022 bytes of a gzipped FileDescriptorSet + // 9000 bytes of a gzipped FileDescriptorSet 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6b, 0x74, 0x1c, 0xe7, 0x75, 0x18, 0x67, 0x1f, 0xc0, 0xee, 0xc5, 0x6b, 0xf1, 0x01, 0xa4, 0x96, 0x4b, 0x0a, 0x80, 0x46, - 0xb2, 0x44, 0x51, 0xd2, 0x42, 0xa2, 0x28, 0x92, 0x5a, 0xc6, 0x96, 0xb1, 0xc0, 0x12, 0x04, 0x89, + 0xb2, 0x44, 0x51, 0xd2, 0x42, 0xa2, 0x28, 0x92, 0x5a, 0xda, 0x96, 0xb1, 0xc0, 0x12, 0x04, 0x89, 0x97, 0x06, 0x20, 0x25, 0xdb, 0x49, 0xe7, 0x0c, 0x66, 0x3f, 0x2c, 0x46, 0x9c, 0x9d, 0x19, 0xcd, - 0xcc, 0x92, 0x00, 0x6d, 0x9f, 0xa3, 0xc4, 0x8f, 0xc6, 0x6a, 0x53, 0xdb, 0x4d, 0x4e, 0x6b, 0xbb, - 0x96, 0xeb, 0x47, 0x5b, 0xa7, 0x4e, 0xdb, 0x24, 0x75, 0x9a, 0x36, 0x4d, 0x4f, 0x6b, 0x37, 0x4e, - 0xe2, 0xb4, 0x4d, 0x8f, 0x7d, 0xea, 0xb6, 0x69, 0x4e, 0x4b, 0xa7, 0xb2, 0x4f, 0xeb, 0xb8, 0x6e, - 0x93, 0xb2, 0xea, 0x53, 0x3f, 0xd2, 0xf3, 0xbd, 0xe6, 0xb1, 0x0f, 0xec, 0x2e, 0x44, 0xc9, 0xd6, - 0x89, 0x7e, 0x61, 0xe6, 0xce, 0xbd, 0xf7, 0xbb, 0xf7, 0x7e, 0xf7, 0xde, 0xef, 0x7e, 0xaf, 0x05, - 0x7c, 0x2d, 0x01, 0x27, 0x75, 0xdb, 0xab, 0xdb, 0xde, 0xec, 0x96, 0xe6, 0xe1, 0xd9, 0xe7, 0x1b, - 0xd8, 0xdd, 0x9b, 0xbd, 0xfe, 0xd8, 0x16, 0xf6, 0xb5, 0xc7, 0x66, 0x1d, 0xad, 0x66, 0x58, 0x9a, - 0x6f, 0xd8, 0x56, 0xd1, 0x71, 0x6d, 0xdf, 0x46, 0x47, 0x19, 0x6e, 0x91, 0xe0, 0x16, 0x29, 0x6e, - 0x91, 0xe3, 0xca, 0x16, 0x0c, 0xad, 0x6b, 0x35, 0xac, 0xe0, 0xe7, 0x1b, 0xd8, 0xf3, 0x51, 0x0e, - 0x92, 0xd7, 0xf0, 0x5e, 0x5e, 0x9a, 0x91, 0x4e, 0x0c, 0x2b, 0xe4, 0x11, 0x1d, 0x81, 0x01, 0x7b, - 0x7b, 0xdb, 0xc3, 0x7e, 0x3e, 0x31, 0x23, 0x9d, 0x48, 0x29, 0xfc, 0x0d, 0x4d, 0x42, 0xda, 0x34, - 0xea, 0x86, 0x9f, 0x4f, 0x52, 0x30, 0x7b, 0x41, 0xd3, 0x30, 0xa4, 0xdb, 0x0d, 0xcb, 0x57, 0x7d, - 0xdb, 0xd7, 0xcc, 0x7c, 0x6a, 0x46, 0x3a, 0x91, 0x51, 0x80, 0x82, 0x36, 0x09, 0x44, 0x7e, 0x0a, - 0x86, 0x59, 0x7b, 0x9e, 0x63, 0x5b, 0x1e, 0x46, 0x47, 0x21, 0x63, 0xe1, 0x5d, 0x5f, 0x0d, 0x5b, - 0x1d, 0x24, 0xef, 0x97, 0xf1, 0x1e, 0x69, 0x81, 0x71, 0x61, 0x0d, 0xb3, 0x97, 0x72, 0xf9, 0xeb, - 0x2f, 0x4f, 0x49, 0xdf, 0x78, 0x79, 0x4a, 0xfa, 0x83, 0x97, 0xa7, 0xa4, 0x8f, 0x7d, 0x67, 0xea, - 0xd0, 0x37, 0xbe, 0x33, 0x75, 0xe8, 0xf7, 0xbe, 0x33, 0x75, 0xe8, 0xdd, 0x27, 0x6a, 0x86, 0xbf, - 0xd3, 0xd8, 0x2a, 0xea, 0x76, 0x7d, 0x96, 0x1b, 0x87, 0xfd, 0x79, 0xc4, 0xab, 0x5e, 0x9b, 0xf5, - 0xf7, 0x1c, 0xec, 0x31, 0x43, 0x6d, 0x0d, 0x50, 0xb3, 0x3c, 0x0e, 0xbf, 0x71, 0x1e, 0x66, 0x6a, - 0xb6, 0x5d, 0x33, 0xf1, 0x2c, 0x85, 0x6c, 0x35, 0xb6, 0x67, 0xab, 0xd8, 0xd3, 0x5d, 0xc3, 0xf1, - 0x6d, 0x97, 0x1b, 0x6f, 0x8c, 0x61, 0x14, 0x05, 0x86, 0xbc, 0x02, 0xe3, 0x17, 0x0c, 0x13, 0x2f, - 0x04, 0x88, 0x1b, 0xd8, 0x47, 0xe7, 0x20, 0xb5, 0x6d, 0x98, 0x38, 0x2f, 0xcd, 0x24, 0x4f, 0x0c, - 0x9d, 0xba, 0xaf, 0xd8, 0x44, 0x54, 0x8c, 0x53, 0xac, 0x13, 0xb0, 0x42, 0x29, 0xe4, 0xef, 0xa6, - 0x60, 0xa2, 0xcd, 0x57, 0x84, 0x20, 0x65, 0x69, 0x75, 0x4c, 0xad, 0x92, 0x55, 0xe8, 0x33, 0xca, - 0xc3, 0xa0, 0xa3, 0xe9, 0xd7, 0xb4, 0x1a, 0xa6, 0x46, 0xc9, 0x2a, 0xe2, 0x15, 0x4d, 0x01, 0x54, - 0xb1, 0x83, 0xad, 0x2a, 0xb6, 0xf4, 0xbd, 0x7c, 0x72, 0x26, 0x79, 0x22, 0xab, 0x44, 0x20, 0xe8, - 0x21, 0x18, 0x77, 0x1a, 0x5b, 0xa6, 0xa1, 0xab, 0x11, 0x34, 0x98, 0x49, 0x9e, 0x48, 0x2b, 0x39, - 0xf6, 0x61, 0x21, 0x44, 0x7e, 0x00, 0xc6, 0x6e, 0x60, 0xed, 0x5a, 0x14, 0x75, 0x88, 0xa2, 0x8e, - 0x12, 0x70, 0x04, 0x71, 0x1e, 0x86, 0xeb, 0xd8, 0xf3, 0xb4, 0x1a, 0x56, 0x89, 0x7d, 0xf3, 0x29, - 0xaa, 0xfd, 0x4c, 0x8b, 0xf6, 0xcd, 0x9a, 0x0f, 0x71, 0xaa, 0xcd, 0x3d, 0x07, 0xa3, 0x39, 0xc8, - 0x62, 0xab, 0x51, 0x67, 0x1c, 0xd2, 0x1d, 0xec, 0x57, 0xb1, 0x1a, 0xf5, 0x66, 0x2e, 0x19, 0x42, - 0xc6, 0x59, 0x0c, 0x7a, 0xd8, 0xbd, 0x6e, 0xe8, 0x38, 0x3f, 0x40, 0x19, 0x3c, 0xd0, 0xc2, 0x60, - 0x83, 0x7d, 0x6f, 0xe6, 0x21, 0xe8, 0xd0, 0x3c, 0x64, 0xf1, 0xae, 0x8f, 0x2d, 0xcf, 0xb0, 0xad, - 0xfc, 0x20, 0x65, 0xf2, 0xb6, 0x36, 0xbd, 0x88, 0xcd, 0x6a, 0x33, 0x8b, 0x90, 0x0e, 0x9d, 0x81, - 0x41, 0xdb, 0x21, 0x81, 0xe7, 0xe5, 0x33, 0x33, 0xd2, 0x89, 0xa1, 0x53, 0xc7, 0xdb, 0x3a, 0xc2, - 0x1a, 0xc3, 0x51, 0x04, 0x32, 0x5a, 0x82, 0x9c, 0x67, 0x37, 0x5c, 0x1d, 0xab, 0xba, 0x5d, 0xc5, - 0xaa, 0x61, 0x6d, 0xdb, 0xf9, 0x2c, 0x65, 0x30, 0xdd, 0xaa, 0x08, 0x45, 0x9c, 0xb7, 0xab, 0x78, - 0xc9, 0xda, 0xb6, 0x95, 0x51, 0x2f, 0xf6, 0x4e, 0xe2, 0xd5, 0xdb, 0xb3, 0x7c, 0x6d, 0x37, 0x3f, - 0x4c, 0x3d, 0x84, 0xbf, 0xc9, 0xbf, 0x36, 0x00, 0x63, 0xbd, 0xb8, 0xd8, 0x79, 0x48, 0x6f, 0x13, - 0x2d, 0xf3, 0x89, 0x7e, 0x6c, 0xc0, 0x68, 0xe2, 0x46, 0x1c, 0x38, 0xa0, 0x11, 0xe7, 0x60, 0xc8, - 0xc2, 0x9e, 0x8f, 0xab, 0xcc, 0x23, 0x92, 0x3d, 0xfa, 0x14, 0x30, 0xa2, 0x56, 0x97, 0x4a, 0x1d, - 0xc8, 0xa5, 0x9e, 0x85, 0xb1, 0x40, 0x24, 0xd5, 0xd5, 0xac, 0x9a, 0xf0, 0xcd, 0xd9, 0x6e, 0x92, - 0x14, 0x2b, 0x82, 0x4e, 0x21, 0x64, 0xca, 0x28, 0x8e, 0xbd, 0xa3, 0x05, 0x00, 0xdb, 0xc2, 0xf6, - 0xb6, 0x5a, 0xc5, 0xba, 0x99, 0xcf, 0x74, 0xb0, 0xd2, 0x1a, 0x41, 0x69, 0xb1, 0x92, 0xcd, 0xa0, - 0xba, 0x89, 0x9e, 0x0c, 0x5d, 0x6d, 0xb0, 0x83, 0xa7, 0xac, 0xb0, 0x20, 0x6b, 0xf1, 0xb6, 0x2b, - 0x30, 0xea, 0x62, 0xe2, 0xf7, 0xb8, 0xca, 0x35, 0xcb, 0x52, 0x21, 0x8a, 0x5d, 0x35, 0x53, 0x38, - 0x19, 0x53, 0x6c, 0xc4, 0x8d, 0xbe, 0xa2, 0x7b, 0x21, 0x00, 0xa8, 0xd4, 0xad, 0x80, 0x66, 0xa1, - 0x61, 0x01, 0x5c, 0xd5, 0xea, 0xb8, 0x70, 0x13, 0x46, 0xe3, 0xe6, 0x21, 0x69, 0xde, 0xf3, 0x35, - 0xd7, 0xa7, 0x5e, 0x98, 0x56, 0xd8, 0x0b, 0x19, 0x88, 0xb0, 0x55, 0xa5, 0x59, 0x2e, 0xad, 0x90, - 0x47, 0xf4, 0xce, 0x50, 0xe1, 0x24, 0x55, 0xf8, 0xfe, 0xd6, 0x1e, 0x8d, 0x71, 0x6e, 0xd6, 0xbb, - 0x70, 0x16, 0x46, 0x62, 0x0a, 0xf4, 0xda, 0xb4, 0xfc, 0x3e, 0x38, 0xdc, 0x96, 0x35, 0x7a, 0x16, - 0x26, 0x1b, 0x96, 0x61, 0xf9, 0xd8, 0x75, 0x5c, 0x4c, 0x3c, 0x96, 0x35, 0x95, 0xff, 0xcf, 0x83, - 0x1d, 0x7c, 0xee, 0x4a, 0x14, 0x9b, 0x71, 0x51, 0x26, 0x1a, 0xad, 0xc0, 0x93, 0xd9, 0xcc, 0xf7, - 0x06, 0x73, 0x2f, 0xbc, 0xf0, 0xc2, 0x0b, 0x09, 0xf9, 0xab, 0x03, 0x30, 0xd9, 0x2e, 0x66, 0xda, - 0x86, 0xef, 0x11, 0x18, 0xb0, 0x1a, 0xf5, 0x2d, 0xec, 0x52, 0x23, 0xa5, 0x15, 0xfe, 0x86, 0xe6, - 0x20, 0x6d, 0x6a, 0x5b, 0x98, 0x0d, 0xc9, 0xa3, 0xa7, 0x1e, 0xea, 0x29, 0x2a, 0x8b, 0xcb, 0x84, - 0x44, 0x61, 0x94, 0xe8, 0x1d, 0x90, 0xe2, 0x29, 0x9a, 0x70, 0x38, 0xd9, 0x1b, 0x07, 0x12, 0x4b, - 0x0a, 0xa5, 0x43, 0xc7, 0x20, 0x4b, 0xfe, 0x32, 0xdf, 0x18, 0xa0, 0x32, 0x67, 0x08, 0x80, 0xf8, - 0x05, 0x2a, 0x40, 0x86, 0x86, 0x49, 0x15, 0x8b, 0xa1, 0x2d, 0x78, 0x27, 0x8e, 0x55, 0xc5, 0xdb, - 0x5a, 0xc3, 0xf4, 0xd5, 0xeb, 0x9a, 0xd9, 0xc0, 0xd4, 0xe1, 0xb3, 0xca, 0x30, 0x07, 0x5e, 0x25, - 0x30, 0x52, 0x79, 0xb0, 0xa8, 0x32, 0xac, 0x2a, 0xde, 0xa5, 0xd9, 0x33, 0xad, 0xb0, 0x40, 0x5b, - 0x22, 0x10, 0xd2, 0xfc, 0x73, 0x9e, 0x6d, 0x09, 0xd7, 0xa4, 0x4d, 0x10, 0x00, 0x6d, 0xfe, 0x6c, - 0x73, 0xe2, 0xbe, 0xbb, 0xbd, 0x7a, 0x2d, 0xb1, 0xf4, 0x00, 0x8c, 0xb1, 0x62, 0x82, 0x77, 0xbd, - 0x66, 0xe6, 0xc7, 0x69, 0xd1, 0x33, 0xca, 0xc0, 0x6b, 0x1c, 0x2a, 0xff, 0x6a, 0x02, 0x52, 0x34, - 0xb1, 0x8c, 0xc1, 0xd0, 0xe6, 0xbb, 0xd6, 0x2b, 0xea, 0xc2, 0xda, 0x95, 0xf2, 0x72, 0x25, 0x27, - 0xa1, 0x51, 0x00, 0x0a, 0xb8, 0xb0, 0xbc, 0x36, 0xb7, 0x99, 0x4b, 0x04, 0xef, 0x4b, 0xab, 0x9b, - 0x67, 0x4e, 0xe7, 0x92, 0x01, 0xc1, 0x15, 0x06, 0x48, 0x45, 0x11, 0x1e, 0x3f, 0x95, 0x4b, 0xa3, - 0x1c, 0x0c, 0x33, 0x06, 0x4b, 0xcf, 0x56, 0x16, 0xce, 0x9c, 0xce, 0x0d, 0xc4, 0x21, 0x8f, 0x9f, - 0xca, 0x0d, 0xa2, 0x11, 0xc8, 0x52, 0x48, 0x79, 0x6d, 0x6d, 0x39, 0x97, 0x09, 0x78, 0x6e, 0x6c, - 0x2a, 0x4b, 0xab, 0x8b, 0xb9, 0x6c, 0xc0, 0x73, 0x51, 0x59, 0xbb, 0xb2, 0x9e, 0x83, 0x80, 0xc3, - 0x4a, 0x65, 0x63, 0x63, 0x6e, 0xb1, 0x92, 0x1b, 0x0a, 0x30, 0xca, 0xef, 0xda, 0xac, 0x6c, 0xe4, - 0x86, 0x63, 0x62, 0x3d, 0x7e, 0x2a, 0x37, 0x12, 0x34, 0x51, 0x59, 0xbd, 0xb2, 0x92, 0x1b, 0x45, - 0xe3, 0x30, 0xc2, 0x9a, 0x10, 0x42, 0x8c, 0x35, 0x81, 0xce, 0x9c, 0xce, 0xe5, 0x42, 0x41, 0x18, - 0x97, 0xf1, 0x18, 0xe0, 0xcc, 0xe9, 0x1c, 0x92, 0xe7, 0x21, 0x4d, 0xdd, 0x10, 0x21, 0x18, 0x5d, - 0x9e, 0x2b, 0x57, 0x96, 0xd5, 0xb5, 0xf5, 0xcd, 0xa5, 0xb5, 0xd5, 0xb9, 0xe5, 0x9c, 0x14, 0xc2, - 0x94, 0xca, 0xd3, 0x57, 0x96, 0x94, 0xca, 0x42, 0x2e, 0x11, 0x85, 0xad, 0x57, 0xe6, 0x36, 0x2b, - 0x0b, 0xb9, 0xa4, 0xac, 0xc3, 0x64, 0xbb, 0x84, 0xda, 0x36, 0x84, 0x22, 0xbe, 0x90, 0xe8, 0xe0, - 0x0b, 0x94, 0x57, 0xb3, 0x2f, 0xc8, 0xdf, 0x49, 0xc0, 0x44, 0x9b, 0x41, 0xa5, 0x6d, 0x23, 0x4f, - 0x41, 0x9a, 0xf9, 0x32, 0x1b, 0x66, 0x1f, 0x6c, 0x3b, 0x3a, 0x51, 0xcf, 0x6e, 0x19, 0x6a, 0x29, - 0x5d, 0xb4, 0xd4, 0x48, 0x76, 0x28, 0x35, 0x08, 0x8b, 0x16, 0x87, 0xfd, 0x89, 0x96, 0xe4, 0xcf, - 0xc6, 0xc7, 0x33, 0xbd, 0x8c, 0x8f, 0x14, 0xd6, 0xdf, 0x20, 0x90, 0x6e, 0x33, 0x08, 0x9c, 0x87, - 0xf1, 0x16, 0x46, 0x3d, 0x27, 0xe3, 0x0f, 0x48, 0x90, 0xef, 0x64, 0x9c, 0x2e, 0x29, 0x31, 0x11, - 0x4b, 0x89, 0xe7, 0x9b, 0x2d, 0x78, 0x4f, 0xe7, 0x4e, 0x68, 0xe9, 0xeb, 0x2f, 0x4a, 0x70, 0xa4, - 0x7d, 0x49, 0xd9, 0x56, 0x86, 0x77, 0xc0, 0x40, 0x1d, 0xfb, 0x3b, 0xb6, 0x28, 0xab, 0xee, 0x6f, - 0x33, 0x58, 0x93, 0xcf, 0xcd, 0x9d, 0xcd, 0xa9, 0xa2, 0xa3, 0x7d, 0xb2, 0x53, 0x5d, 0xc8, 0xa4, - 0x69, 0x91, 0xf4, 0x23, 0x09, 0x38, 0xdc, 0x96, 0x79, 0x5b, 0x41, 0xef, 0x06, 0x30, 0x2c, 0xa7, - 0xe1, 0xb3, 0xd2, 0x89, 0x65, 0xe2, 0x2c, 0x85, 0xd0, 0xe4, 0x45, 0xb2, 0x6c, 0xc3, 0x0f, 0xbe, - 0x27, 0xe9, 0x77, 0x60, 0x20, 0x8a, 0x70, 0x2e, 0x14, 0x34, 0x45, 0x05, 0x9d, 0xea, 0xa0, 0x69, - 0x8b, 0x63, 0x3e, 0x0a, 0x39, 0xdd, 0x34, 0xb0, 0xe5, 0xab, 0x9e, 0xef, 0x62, 0xad, 0x6e, 0x58, - 0x35, 0x3a, 0xd4, 0x64, 0x4a, 0xe9, 0x6d, 0xcd, 0xf4, 0xb0, 0x32, 0xc6, 0x3e, 0x6f, 0x88, 0xaf, - 0x84, 0x82, 0x3a, 0x90, 0x1b, 0xa1, 0x18, 0x88, 0x51, 0xb0, 0xcf, 0x01, 0x85, 0xfc, 0xf1, 0x2c, - 0x0c, 0x45, 0x0a, 0x70, 0x74, 0x0f, 0x0c, 0x3f, 0xa7, 0x5d, 0xd7, 0x54, 0x31, 0xa9, 0x62, 0x96, - 0x18, 0x22, 0xb0, 0x75, 0x3e, 0xb1, 0x7a, 0x14, 0x26, 0x29, 0x8a, 0xdd, 0xf0, 0xb1, 0xab, 0xea, - 0xa6, 0xe6, 0x79, 0xd4, 0x68, 0x19, 0x8a, 0x8a, 0xc8, 0xb7, 0x35, 0xf2, 0x69, 0x5e, 0x7c, 0x41, - 0x4f, 0xc0, 0x04, 0xa5, 0xa8, 0x37, 0x4c, 0xdf, 0x70, 0x4c, 0xac, 0x92, 0x69, 0x9e, 0x47, 0x87, - 0x9c, 0x40, 0xb2, 0x71, 0x82, 0xb1, 0xc2, 0x11, 0x88, 0x44, 0x1e, 0x5a, 0x80, 0xbb, 0x29, 0x59, - 0x0d, 0x5b, 0xd8, 0xd5, 0x7c, 0xac, 0xe2, 0xe7, 0x1b, 0x9a, 0xe9, 0xa9, 0x9a, 0x55, 0x55, 0x77, - 0x34, 0x6f, 0x27, 0x3f, 0x49, 0x18, 0x94, 0x13, 0x79, 0x49, 0x39, 0x4a, 0x10, 0x17, 0x39, 0x5e, - 0x85, 0xa2, 0xcd, 0x59, 0xd5, 0x8b, 0x9a, 0xb7, 0x83, 0x4a, 0x70, 0x84, 0x72, 0xf1, 0x7c, 0xd7, - 0xb0, 0x6a, 0xaa, 0xbe, 0x83, 0xf5, 0x6b, 0x6a, 0xc3, 0xdf, 0x3e, 0x97, 0x3f, 0x16, 0x6d, 0x9f, - 0x4a, 0xb8, 0x41, 0x71, 0xe6, 0x09, 0xca, 0x15, 0x7f, 0xfb, 0x1c, 0xda, 0x80, 0x61, 0xd2, 0x19, - 0x75, 0xe3, 0x26, 0x56, 0xb7, 0x6d, 0x97, 0x8e, 0xa1, 0xa3, 0x6d, 0x52, 0x53, 0xc4, 0x82, 0xc5, - 0x35, 0x4e, 0xb0, 0x62, 0x57, 0x71, 0x29, 0xbd, 0xb1, 0x5e, 0xa9, 0x2c, 0x28, 0x43, 0x82, 0xcb, - 0x05, 0xdb, 0x25, 0x0e, 0x55, 0xb3, 0x03, 0x03, 0x0f, 0x31, 0x87, 0xaa, 0xd9, 0xc2, 0xbc, 0x4f, - 0xc0, 0x84, 0xae, 0x33, 0x9d, 0x0d, 0x5d, 0xe5, 0x93, 0x31, 0x2f, 0x9f, 0x8b, 0x19, 0x4b, 0xd7, - 0x17, 0x19, 0x02, 0xf7, 0x71, 0x0f, 0x3d, 0x09, 0x87, 0x43, 0x63, 0x45, 0x09, 0xc7, 0x5b, 0xb4, - 0x6c, 0x26, 0x7d, 0x02, 0x26, 0x9c, 0xbd, 0x56, 0x42, 0x14, 0x6b, 0xd1, 0xd9, 0x6b, 0x26, 0x3b, - 0x0b, 0x93, 0xce, 0x8e, 0xd3, 0x4a, 0x77, 0x32, 0x4a, 0x87, 0x9c, 0x1d, 0xa7, 0x99, 0xf0, 0x6d, - 0x74, 0x66, 0xee, 0x62, 0x5d, 0xf3, 0x71, 0x35, 0x7f, 0x57, 0x14, 0x3d, 0xf2, 0x01, 0x15, 0x21, - 0xa7, 0xeb, 0x2a, 0xb6, 0xb4, 0x2d, 0x13, 0xab, 0x9a, 0x8b, 0x2d, 0xcd, 0xcb, 0x4f, 0x53, 0xe4, - 0x94, 0xef, 0x36, 0xb0, 0x32, 0xaa, 0xeb, 0x15, 0xfa, 0x71, 0x8e, 0x7e, 0x43, 0x27, 0x61, 0xdc, - 0xde, 0x7a, 0x4e, 0x67, 0x1e, 0xa9, 0x3a, 0x2e, 0xde, 0x36, 0x76, 0xf3, 0xf7, 0x51, 0xf3, 0x8e, - 0x91, 0x0f, 0xd4, 0x1f, 0xd7, 0x29, 0x18, 0x3d, 0x08, 0x39, 0xdd, 0xdb, 0xd1, 0x5c, 0x87, 0xa6, - 0x64, 0xcf, 0xd1, 0x74, 0x9c, 0x7f, 0x1b, 0x43, 0x65, 0xf0, 0x55, 0x01, 0x26, 0x11, 0xe1, 0xdd, - 0x30, 0xb6, 0x7d, 0xc1, 0xf1, 0x01, 0x16, 0x11, 0x14, 0xc6, 0xb9, 0x9d, 0x80, 0x1c, 0xb1, 0x44, - 0xac, 0xe1, 0x13, 0x14, 0x6d, 0xd4, 0xd9, 0x71, 0xa2, 0xed, 0xde, 0x0b, 0x23, 0x04, 0x33, 0x6c, - 0xf4, 0x41, 0x56, 0xb8, 0x39, 0x3b, 0x91, 0x16, 0x4f, 0xc3, 0x11, 0x82, 0x54, 0xc7, 0xbe, 0x56, - 0xd5, 0x7c, 0x2d, 0x82, 0xfd, 0x30, 0xc5, 0x26, 0x66, 0x5f, 0xe1, 0x1f, 0x63, 0x72, 0xba, 0x8d, - 0xad, 0xbd, 0xc0, 0xb1, 0x1e, 0x61, 0x72, 0x12, 0x98, 0x70, 0xad, 0xd7, 0xad, 0x38, 0x97, 0x4b, - 0x30, 0x1c, 0xf5, 0x7b, 0x94, 0x05, 0xe6, 0xf9, 0x39, 0x89, 0x14, 0x41, 0xf3, 0x6b, 0x0b, 0xa4, - 0x7c, 0x79, 0x77, 0x25, 0x97, 0x20, 0x65, 0xd4, 0xf2, 0xd2, 0x66, 0x45, 0x55, 0xae, 0xac, 0x6e, - 0x2e, 0xad, 0x54, 0x72, 0xc9, 0x48, 0x61, 0x7f, 0x29, 0x95, 0xb9, 0x3f, 0xf7, 0x80, 0xfc, 0xcd, - 0x04, 0x8c, 0xc6, 0x67, 0x6a, 0xe8, 0xc7, 0xe0, 0x2e, 0xb1, 0xac, 0xe2, 0x61, 0x5f, 0xbd, 0x61, - 0xb8, 0x34, 0x20, 0xeb, 0x1a, 0x1b, 0x1c, 0x03, 0xff, 0x99, 0xe4, 0x58, 0x1b, 0xd8, 0x7f, 0xc6, - 0x70, 0x49, 0xb8, 0xd5, 0x35, 0x1f, 0x2d, 0xc3, 0xb4, 0x65, 0xab, 0x9e, 0xaf, 0x59, 0x55, 0xcd, - 0xad, 0xaa, 0xe1, 0x82, 0x96, 0xaa, 0xe9, 0x3a, 0xf6, 0x3c, 0x9b, 0x0d, 0x84, 0x01, 0x97, 0xe3, - 0x96, 0xbd, 0xc1, 0x91, 0xc3, 0x11, 0x62, 0x8e, 0xa3, 0x36, 0xb9, 0x6f, 0xb2, 0x93, 0xfb, 0x1e, - 0x83, 0x6c, 0x5d, 0x73, 0x54, 0x6c, 0xf9, 0xee, 0x1e, 0xad, 0xcf, 0x33, 0x4a, 0xa6, 0xae, 0x39, - 0x15, 0xf2, 0xfe, 0x86, 0x4c, 0x93, 0x2e, 0xa5, 0x32, 0x99, 0x5c, 0xf6, 0x52, 0x2a, 0x93, 0xcd, - 0x81, 0xfc, 0x72, 0x12, 0x86, 0xa3, 0xf5, 0x3a, 0x99, 0xfe, 0xe8, 0x74, 0xc4, 0x92, 0x68, 0x4e, - 0xbb, 0x77, 0xdf, 0xea, 0xbe, 0x38, 0x4f, 0x86, 0xb2, 0xd2, 0x00, 0x2b, 0x8e, 0x15, 0x46, 0x49, - 0xca, 0x08, 0xe2, 0x6c, 0x98, 0x15, 0x23, 0x19, 0x85, 0xbf, 0xa1, 0x45, 0x18, 0x78, 0xce, 0xa3, - 0xbc, 0x07, 0x28, 0xef, 0xfb, 0xf6, 0xe7, 0x7d, 0x69, 0x83, 0x32, 0xcf, 0x5e, 0xda, 0x50, 0x57, - 0xd7, 0x94, 0x95, 0xb9, 0x65, 0x85, 0x93, 0xa3, 0xa3, 0x90, 0x32, 0xb5, 0x9b, 0x7b, 0xf1, 0x41, - 0x8f, 0x82, 0x7a, 0xed, 0x84, 0xa3, 0x90, 0xba, 0x81, 0xb5, 0x6b, 0xf1, 0xa1, 0x86, 0x82, 0x5e, - 0xc7, 0x60, 0x98, 0x85, 0x34, 0xb5, 0x17, 0x02, 0xe0, 0x16, 0xcb, 0x1d, 0x42, 0x19, 0x48, 0xcd, - 0xaf, 0x29, 0x24, 0x20, 0x72, 0x30, 0xcc, 0xa0, 0xea, 0xfa, 0x52, 0x65, 0xbe, 0x92, 0x4b, 0xc8, - 0x4f, 0xc0, 0x00, 0x33, 0x02, 0x09, 0x96, 0xc0, 0x0c, 0xb9, 0x43, 0xfc, 0x95, 0xf3, 0x90, 0xc4, - 0xd7, 0x2b, 0x2b, 0xe5, 0x8a, 0x92, 0x4b, 0xc4, 0xbb, 0x3a, 0x95, 0x4b, 0xcb, 0x1e, 0x0c, 0x47, - 0xeb, 0xf0, 0x37, 0x66, 0x32, 0xfe, 0x15, 0x09, 0x86, 0x22, 0x75, 0x35, 0x29, 0x88, 0x34, 0xd3, - 0xb4, 0x6f, 0xa8, 0x9a, 0x69, 0x68, 0x1e, 0x77, 0x0d, 0xa0, 0xa0, 0x39, 0x02, 0xe9, 0xb5, 0xeb, - 0xde, 0xa0, 0x10, 0x49, 0xe7, 0x06, 0xe4, 0xcf, 0x48, 0x90, 0x6b, 0x2e, 0x6c, 0x9b, 0xc4, 0x94, - 0x7e, 0x98, 0x62, 0xca, 0x9f, 0x96, 0x60, 0x34, 0x5e, 0xcd, 0x36, 0x89, 0x77, 0xcf, 0x0f, 0x55, - 0xbc, 0x3f, 0x48, 0xc0, 0x48, 0xac, 0x86, 0xed, 0x55, 0xba, 0xe7, 0x61, 0xdc, 0xa8, 0xe2, 0xba, - 0x63, 0xfb, 0xd8, 0xd2, 0xf7, 0x54, 0x13, 0x5f, 0xc7, 0x66, 0x5e, 0xa6, 0x49, 0x63, 0x76, 0xff, - 0x2a, 0xb9, 0xb8, 0x14, 0xd2, 0x2d, 0x13, 0xb2, 0xd2, 0xc4, 0xd2, 0x42, 0x65, 0x65, 0x7d, 0x6d, - 0xb3, 0xb2, 0x3a, 0xff, 0x2e, 0xf5, 0xca, 0xea, 0xe5, 0xd5, 0xb5, 0x67, 0x56, 0x95, 0x9c, 0xd1, - 0x84, 0xf6, 0x3a, 0x86, 0xfd, 0x3a, 0xe4, 0x9a, 0x85, 0x42, 0x77, 0x41, 0x3b, 0xb1, 0x72, 0x87, - 0xd0, 0x04, 0x8c, 0xad, 0xae, 0xa9, 0x1b, 0x4b, 0x0b, 0x15, 0xb5, 0x72, 0xe1, 0x42, 0x65, 0x7e, - 0x73, 0x83, 0xad, 0x7b, 0x04, 0xd8, 0x9b, 0xb1, 0x00, 0x97, 0x3f, 0x95, 0x84, 0x89, 0x36, 0x92, - 0xa0, 0x39, 0x3e, 0x63, 0x61, 0x93, 0xa8, 0x47, 0x7a, 0x91, 0xbe, 0x48, 0x6a, 0x86, 0x75, 0xcd, - 0xf5, 0xf9, 0x04, 0xe7, 0x41, 0x20, 0x56, 0xb2, 0x7c, 0x63, 0xdb, 0xc0, 0x2e, 0x5f, 0x4f, 0x62, - 0xd3, 0x98, 0xb1, 0x10, 0xce, 0x96, 0x94, 0x1e, 0x06, 0xe4, 0xd8, 0x9e, 0xe1, 0x1b, 0xd7, 0xb1, - 0x6a, 0x58, 0x62, 0xf1, 0x29, 0x45, 0x77, 0xa3, 0x72, 0xe2, 0xcb, 0x92, 0xe5, 0x07, 0xd8, 0x16, - 0xae, 0x69, 0x4d, 0xd8, 0x24, 0x99, 0x27, 0x95, 0x9c, 0xf8, 0x12, 0x60, 0xdf, 0x03, 0xc3, 0x55, - 0xbb, 0x41, 0x6a, 0x3d, 0x86, 0x47, 0xc6, 0x0e, 0x49, 0x19, 0x62, 0xb0, 0x00, 0x85, 0x57, 0xf1, - 0xe1, 0xaa, 0xd7, 0xb0, 0x32, 0xc4, 0x60, 0x0c, 0xe5, 0x01, 0x18, 0xd3, 0x6a, 0x35, 0x97, 0x30, - 0x17, 0x8c, 0xd8, 0xbc, 0x64, 0x34, 0x00, 0x53, 0xc4, 0xc2, 0x25, 0xc8, 0x08, 0x3b, 0x90, 0xa1, - 0x9a, 0x58, 0x42, 0x75, 0xd8, 0x64, 0x3b, 0x71, 0x22, 0xab, 0x64, 0x2c, 0xf1, 0xf1, 0x1e, 0x18, - 0x36, 0x3c, 0x35, 0x5c, 0xc4, 0x4f, 0xcc, 0x24, 0x4e, 0x64, 0x94, 0x21, 0xc3, 0x0b, 0x16, 0x40, - 0xe5, 0x2f, 0x26, 0x60, 0x34, 0xbe, 0x09, 0x81, 0x16, 0x20, 0x63, 0xda, 0x3a, 0xdd, 0x72, 0xe4, - 0x3b, 0x60, 0x27, 0xba, 0xec, 0x5b, 0x14, 0x97, 0x39, 0xbe, 0x12, 0x50, 0x16, 0xfe, 0xa5, 0x04, - 0x19, 0x01, 0x46, 0x47, 0x20, 0xe5, 0x68, 0xfe, 0x0e, 0x65, 0x97, 0x2e, 0x27, 0x72, 0x92, 0x42, - 0xdf, 0x09, 0xdc, 0x73, 0x34, 0x8b, 0xba, 0x00, 0x87, 0x93, 0x77, 0xd2, 0xaf, 0x26, 0xd6, 0xaa, - 0x74, 0xd2, 0x63, 0xd7, 0xeb, 0xd8, 0xf2, 0x3d, 0xd1, 0xaf, 0x1c, 0x3e, 0xcf, 0xc1, 0xe8, 0x21, - 0x18, 0xf7, 0x5d, 0xcd, 0x30, 0x63, 0xb8, 0x29, 0x8a, 0x9b, 0x13, 0x1f, 0x02, 0xe4, 0x12, 0x1c, - 0x15, 0x7c, 0xab, 0xd8, 0xd7, 0xf4, 0x1d, 0x5c, 0x0d, 0x89, 0x06, 0xe8, 0xe2, 0xc6, 0x5d, 0x1c, - 0x61, 0x81, 0x7f, 0x17, 0xb4, 0xf2, 0x37, 0x25, 0x18, 0x17, 0xd3, 0xb4, 0x6a, 0x60, 0xac, 0x15, - 0x00, 0xcd, 0xb2, 0x6c, 0x3f, 0x6a, 0xae, 0x56, 0x57, 0x6e, 0xa1, 0x2b, 0xce, 0x05, 0x44, 0x4a, - 0x84, 0x41, 0xa1, 0x0e, 0x10, 0x7e, 0xe9, 0x68, 0xb6, 0x69, 0x18, 0xe2, 0x3b, 0x4c, 0x74, 0x9b, - 0x92, 0x4d, 0xec, 0x81, 0x81, 0xc8, 0x7c, 0x0e, 0x4d, 0x42, 0x7a, 0x0b, 0xd7, 0x0c, 0x8b, 0xaf, - 0x1b, 0xb3, 0x17, 0xb1, 0xfc, 0x92, 0x0a, 0x96, 0x5f, 0xca, 0x1f, 0x95, 0x60, 0x42, 0xb7, 0xeb, - 0xcd, 0xf2, 0x96, 0x73, 0x4d, 0xab, 0x0b, 0xde, 0x45, 0xe9, 0xdd, 0xef, 0x88, 0xec, 0xc8, 0xd6, - 0x6c, 0x53, 0xb3, 0x6a, 0xe1, 0x3e, 0x2b, 0x7d, 0xd0, 0x1f, 0xa9, 0x61, 0xeb, 0x91, 0x9a, 0x1d, - 0xd9, 0x75, 0x3d, 0x1f, 0x3e, 0xfe, 0x1f, 0x49, 0xfa, 0x7c, 0x22, 0xb9, 0xb8, 0x5e, 0xfe, 0x52, - 0xa2, 0xb0, 0xc8, 0x9a, 0x5b, 0x17, 0xe6, 0x51, 0xf0, 0xb6, 0x89, 0x75, 0xa2, 0x32, 0x7c, 0xff, - 0x21, 0x98, 0xac, 0xd9, 0x35, 0x9b, 0x72, 0x9c, 0x25, 0x4f, 0x7c, 0xe7, 0x36, 0x1b, 0x40, 0x0b, - 0x5d, 0xb7, 0x79, 0x4b, 0xab, 0x30, 0xc1, 0x91, 0x55, 0xba, 0x75, 0xc4, 0x26, 0x36, 0x68, 0xdf, - 0x55, 0xb5, 0xfc, 0x2f, 0x7f, 0x97, 0x0e, 0xe8, 0xca, 0x38, 0x27, 0x25, 0xdf, 0xd8, 0xdc, 0xa7, - 0xa4, 0xc0, 0xe1, 0x18, 0x3f, 0x16, 0xb6, 0xd8, 0xed, 0xc2, 0xf1, 0x37, 0x39, 0xc7, 0x89, 0x08, - 0xc7, 0x0d, 0x4e, 0x5a, 0x9a, 0x87, 0x91, 0x7e, 0x78, 0xfd, 0x16, 0xe7, 0x35, 0x8c, 0xa3, 0x4c, - 0x16, 0x61, 0x8c, 0x32, 0xd1, 0x1b, 0x9e, 0x6f, 0xd7, 0x69, 0x4e, 0xdc, 0x9f, 0xcd, 0x6f, 0x7f, - 0x97, 0xc5, 0xd1, 0x28, 0x21, 0x9b, 0x0f, 0xa8, 0x4a, 0x25, 0xa0, 0xbb, 0x65, 0x55, 0xac, 0x9b, - 0x5d, 0x38, 0x7c, 0x9d, 0x0b, 0x12, 0xe0, 0x97, 0xae, 0xc2, 0x24, 0x79, 0xa6, 0x29, 0x2b, 0x2a, - 0x49, 0xf7, 0x25, 0xb8, 0xfc, 0x37, 0x3f, 0xc0, 0x42, 0x75, 0x22, 0x60, 0x10, 0x91, 0x29, 0xd2, - 0x8b, 0x35, 0xec, 0xfb, 0xd8, 0xf5, 0x54, 0xcd, 0x6c, 0x27, 0x5e, 0x64, 0x0d, 0x23, 0xff, 0xc9, - 0x1f, 0xc4, 0x7b, 0x71, 0x91, 0x51, 0xce, 0x99, 0x66, 0xe9, 0x0a, 0xdc, 0xd5, 0xc6, 0x2b, 0x7a, - 0xe0, 0xf9, 0x29, 0xce, 0x73, 0xb2, 0xc5, 0x33, 0x08, 0xdb, 0x75, 0x10, 0xf0, 0xa0, 0x2f, 0x7b, - 0xe0, 0xf9, 0x57, 0x38, 0x4f, 0xc4, 0x69, 0x45, 0x97, 0x12, 0x8e, 0x97, 0x60, 0xfc, 0x3a, 0x76, - 0xb7, 0x6c, 0x8f, 0xaf, 0x1b, 0xf5, 0xc0, 0xee, 0xd3, 0x9c, 0xdd, 0x18, 0x27, 0xa4, 0x0b, 0x49, - 0x84, 0xd7, 0x93, 0x90, 0xd9, 0xd6, 0x74, 0xdc, 0x03, 0x8b, 0x97, 0x38, 0x8b, 0x41, 0x82, 0x4f, - 0x48, 0xe7, 0x60, 0xb8, 0x66, 0xf3, 0x51, 0xab, 0x3b, 0xf9, 0x67, 0x38, 0xf9, 0x90, 0xa0, 0xe1, - 0x2c, 0x1c, 0xdb, 0x69, 0x98, 0x64, 0x48, 0xeb, 0xce, 0xe2, 0xaf, 0x0a, 0x16, 0x82, 0x86, 0xb3, - 0xe8, 0xc3, 0xac, 0x9f, 0x15, 0x2c, 0xbc, 0x88, 0x3d, 0x9f, 0x82, 0x21, 0xdb, 0x32, 0xf7, 0x6c, - 0xab, 0x17, 0x21, 0x3e, 0xc7, 0x39, 0x00, 0x27, 0x21, 0x0c, 0xce, 0x43, 0xb6, 0xd7, 0x8e, 0xf8, - 0xeb, 0x3f, 0x10, 0xe1, 0x21, 0x7a, 0x60, 0x11, 0xc6, 0x44, 0x82, 0x32, 0x6c, 0xab, 0x07, 0x16, - 0x7f, 0x83, 0xb3, 0x18, 0x8d, 0x90, 0x71, 0x35, 0x7c, 0xec, 0xf9, 0x35, 0xdc, 0x0b, 0x93, 0x2f, - 0x0a, 0x35, 0x38, 0x09, 0x37, 0xe5, 0x16, 0xb6, 0xf4, 0x9d, 0xde, 0x38, 0xfc, 0xbc, 0x30, 0xa5, - 0xa0, 0x21, 0x2c, 0xe6, 0x61, 0xa4, 0xae, 0xb9, 0xde, 0x8e, 0x66, 0xf6, 0xd4, 0x1d, 0x7f, 0x93, - 0xf3, 0x18, 0x0e, 0x88, 0xb8, 0x45, 0x1a, 0x56, 0x3f, 0x6c, 0xbe, 0x24, 0x2c, 0x12, 0x21, 0xe3, - 0xa1, 0xe7, 0xf9, 0x74, 0x91, 0xad, 0x1f, 0x6e, 0xbf, 0x20, 0x42, 0x8f, 0xd1, 0xae, 0x44, 0x39, - 0x9e, 0x87, 0xac, 0x67, 0xdc, 0xec, 0x89, 0xcd, 0xdf, 0x12, 0x3d, 0x4d, 0x09, 0x08, 0xf1, 0xbb, - 0xe0, 0x68, 0xdb, 0x61, 0xa2, 0x07, 0x66, 0x7f, 0x9b, 0x33, 0x3b, 0xd2, 0x66, 0xa8, 0xe0, 0x29, - 0xa1, 0x5f, 0x96, 0x7f, 0x47, 0xa4, 0x04, 0xdc, 0xc4, 0x6b, 0x9d, 0xcc, 0x23, 0x3c, 0x6d, 0xbb, - 0x3f, 0xab, 0xfd, 0xa2, 0xb0, 0x1a, 0xa3, 0x8d, 0x59, 0x6d, 0x13, 0x8e, 0x70, 0x8e, 0xfd, 0xf5, - 0xeb, 0x2f, 0x89, 0xc4, 0xca, 0xa8, 0xaf, 0xc4, 0x7b, 0xf7, 0x3d, 0x50, 0x08, 0xcc, 0x29, 0x0a, - 0x56, 0x4f, 0xad, 0x6b, 0x4e, 0x0f, 0x9c, 0x7f, 0x99, 0x73, 0x16, 0x19, 0x3f, 0xa8, 0x78, 0xbd, - 0x15, 0xcd, 0x21, 0xcc, 0x9f, 0x85, 0xbc, 0x60, 0xde, 0xb0, 0x5c, 0xac, 0xdb, 0x35, 0xcb, 0xb8, - 0x89, 0xab, 0x3d, 0xb0, 0xfe, 0xbb, 0x4d, 0x5d, 0x75, 0x25, 0x42, 0x4e, 0x38, 0x2f, 0x41, 0x2e, - 0xa8, 0x55, 0x54, 0xa3, 0xee, 0xd8, 0xae, 0xdf, 0x85, 0xe3, 0x97, 0x45, 0x4f, 0x05, 0x74, 0x4b, - 0x94, 0xac, 0x54, 0x01, 0xb6, 0xf3, 0xdc, 0xab, 0x4b, 0xfe, 0x0a, 0x67, 0x34, 0x12, 0x52, 0xf1, - 0xc4, 0xa1, 0xdb, 0x75, 0x47, 0x73, 0x7b, 0xc9, 0x7f, 0x7f, 0x4f, 0x24, 0x0e, 0x4e, 0xc2, 0x13, - 0x87, 0xbf, 0xe7, 0x60, 0x32, 0xda, 0xf7, 0xc0, 0xe1, 0x57, 0x45, 0xe2, 0x10, 0x34, 0x9c, 0x85, - 0x28, 0x18, 0x7a, 0x60, 0xf1, 0xf7, 0x05, 0x0b, 0x41, 0x43, 0x58, 0x3c, 0x1d, 0x0e, 0xb4, 0x2e, - 0xae, 0x19, 0x9e, 0xef, 0xb2, 0x32, 0x79, 0x7f, 0x56, 0xff, 0xe0, 0x07, 0xf1, 0x22, 0x4c, 0x89, - 0x90, 0x92, 0x4c, 0xc4, 0x97, 0x5d, 0xe9, 0x2c, 0xaa, 0xbb, 0x60, 0xbf, 0x26, 0x32, 0x51, 0x84, - 0x8c, 0xc8, 0x16, 0xa9, 0x10, 0x89, 0xd9, 0x75, 0x32, 0x77, 0xe8, 0x81, 0xdd, 0x3f, 0x6c, 0x12, - 0x6e, 0x43, 0xd0, 0x12, 0x9e, 0x91, 0xfa, 0xa7, 0x61, 0x5d, 0xc3, 0x7b, 0x3d, 0x79, 0xe7, 0xaf, - 0x37, 0xd5, 0x3f, 0x57, 0x18, 0x25, 0xcb, 0x21, 0x63, 0x4d, 0xf5, 0x14, 0xea, 0x76, 0xce, 0x28, - 0xff, 0x93, 0xaf, 0x70, 0x7d, 0xe3, 0xe5, 0x54, 0x69, 0x99, 0x38, 0x79, 0xbc, 0xe8, 0xe9, 0xce, - 0xec, 0x03, 0xaf, 0x04, 0x7e, 0x1e, 0xab, 0x79, 0x4a, 0x17, 0x60, 0x24, 0x56, 0xf0, 0x74, 0x67, - 0xf5, 0x41, 0xce, 0x6a, 0x38, 0x5a, 0xef, 0x94, 0x9e, 0x80, 0x14, 0x29, 0x5e, 0xba, 0x93, 0x7f, - 0x88, 0x93, 0x53, 0xf4, 0xd2, 0xdb, 0x21, 0x23, 0x8a, 0x96, 0xee, 0xa4, 0x1f, 0xe6, 0xa4, 0x01, - 0x09, 0x21, 0x17, 0x05, 0x4b, 0x77, 0xf2, 0x3f, 0x2b, 0xc8, 0x05, 0x09, 0x21, 0xef, 0xdd, 0x84, - 0x5f, 0xf9, 0x73, 0x29, 0x3e, 0xe8, 0x08, 0xdb, 0x9d, 0x87, 0x41, 0x5e, 0xa9, 0x74, 0xa7, 0xfe, - 0x08, 0x6f, 0x5c, 0x50, 0x94, 0xce, 0x42, 0xba, 0x47, 0x83, 0xff, 0x0c, 0x27, 0x65, 0xf8, 0xa5, - 0x79, 0x18, 0x8a, 0x54, 0x27, 0xdd, 0xc9, 0xff, 0x02, 0x27, 0x8f, 0x52, 0x11, 0xd1, 0x79, 0x75, - 0xd2, 0x9d, 0xc1, 0x47, 0x85, 0xe8, 0x9c, 0x82, 0x98, 0x4d, 0x14, 0x26, 0xdd, 0xa9, 0x3f, 0x26, - 0xac, 0x2e, 0x48, 0x4a, 0x4f, 0x41, 0x36, 0x18, 0x6c, 0xba, 0xd3, 0x7f, 0x9c, 0xd3, 0x87, 0x34, - 0xc4, 0x02, 0x91, 0xc1, 0xae, 0x3b, 0x8b, 0xbf, 0x28, 0x2c, 0x10, 0xa1, 0x22, 0x61, 0xd4, 0x5c, - 0xc0, 0x74, 0xe7, 0xf4, 0xb3, 0x22, 0x8c, 0x9a, 0xea, 0x17, 0xd2, 0x9b, 0x34, 0xe7, 0x77, 0x67, - 0xf1, 0x73, 0xa2, 0x37, 0x29, 0x3e, 0x11, 0xa3, 0xb9, 0x22, 0xe8, 0xce, 0xe3, 0x2f, 0x0b, 0x31, - 0x9a, 0x0a, 0x82, 0xd2, 0x3a, 0xa0, 0xd6, 0x6a, 0xa0, 0x3b, 0xbf, 0x4f, 0x70, 0x7e, 0xe3, 0x2d, - 0xc5, 0x40, 0xe9, 0x19, 0x38, 0xd2, 0xbe, 0x12, 0xe8, 0xce, 0xf5, 0x93, 0xaf, 0x34, 0xcd, 0xdd, - 0xa2, 0x85, 0x40, 0x69, 0x33, 0x1c, 0x52, 0xa2, 0x55, 0x40, 0x77, 0xb6, 0x9f, 0x7a, 0x25, 0x9e, - 0xb8, 0xa3, 0x45, 0x40, 0x69, 0x0e, 0x20, 0x1c, 0x80, 0xbb, 0xf3, 0xfa, 0x34, 0xe7, 0x15, 0x21, - 0x22, 0xa1, 0xc1, 0xc7, 0xdf, 0xee, 0xf4, 0x2f, 0x89, 0xd0, 0xe0, 0x14, 0x24, 0x34, 0xc4, 0xd0, - 0xdb, 0x9d, 0xfa, 0x33, 0x22, 0x34, 0x04, 0x09, 0xf1, 0xec, 0xc8, 0xe8, 0xd6, 0x9d, 0xc3, 0xe7, - 0x84, 0x67, 0x47, 0xa8, 0x4a, 0xab, 0x30, 0xde, 0x32, 0x20, 0x76, 0x67, 0xf5, 0x79, 0xce, 0x2a, - 0xd7, 0x3c, 0x1e, 0x46, 0x07, 0x2f, 0x3e, 0x18, 0x76, 0xe7, 0xf6, 0x85, 0xa6, 0xc1, 0x8b, 0x8f, - 0x85, 0xa5, 0xf3, 0x90, 0xb1, 0x1a, 0xa6, 0x49, 0x82, 0x07, 0xed, 0x7f, 0x36, 0x30, 0xff, 0x87, - 0xaf, 0x72, 0xeb, 0x08, 0x82, 0xd2, 0x13, 0x90, 0xc6, 0xf5, 0x2d, 0x5c, 0xed, 0x46, 0xf9, 0xfd, - 0x57, 0x45, 0xc2, 0x24, 0xd8, 0xa5, 0xa7, 0x00, 0xd8, 0xd2, 0x08, 0xdd, 0x1e, 0xec, 0x42, 0xfb, - 0x5f, 0x5e, 0xe5, 0x87, 0x71, 0x42, 0x92, 0x90, 0x01, 0x3b, 0xda, 0xb3, 0x3f, 0x83, 0x1f, 0xc4, - 0x19, 0xd0, 0x1e, 0x79, 0x12, 0x06, 0x9f, 0xf3, 0x6c, 0xcb, 0xd7, 0x6a, 0xdd, 0xa8, 0xff, 0x2b, - 0xa7, 0x16, 0xf8, 0xc4, 0x60, 0x75, 0xdb, 0xc5, 0xbe, 0x56, 0xf3, 0xba, 0xd1, 0xfe, 0x37, 0x4e, - 0x1b, 0x10, 0x10, 0x62, 0x5d, 0xf3, 0xfc, 0x5e, 0xf4, 0xfe, 0x23, 0x41, 0x2c, 0x08, 0x88, 0xd0, - 0xe4, 0xf9, 0x1a, 0xde, 0xeb, 0x46, 0xfb, 0xc7, 0x42, 0x68, 0x8e, 0x5f, 0x7a, 0x3b, 0x64, 0xc9, - 0x23, 0x3b, 0x61, 0xd7, 0x85, 0xf8, 0xbf, 0x73, 0xe2, 0x90, 0x82, 0xb4, 0xec, 0xf9, 0x55, 0xdf, - 0xe8, 0x6e, 0xec, 0xdb, 0xbc, 0xa7, 0x05, 0x7e, 0x69, 0x0e, 0x86, 0x3c, 0xbf, 0x5a, 0x6d, 0xf0, - 0xfa, 0xb4, 0x0b, 0xf9, 0xff, 0x78, 0x35, 0x58, 0xb2, 0x08, 0x68, 0x48, 0x6f, 0xdf, 0xb8, 0xe6, - 0x3b, 0x36, 0xdd, 0x02, 0xe9, 0xc6, 0xe1, 0x15, 0xce, 0x21, 0x42, 0x52, 0x9a, 0x87, 0x61, 0xa2, - 0x8b, 0x8b, 0x1d, 0x4c, 0xf7, 0xab, 0xba, 0xb0, 0xf8, 0x9f, 0xdc, 0x00, 0x31, 0xa2, 0xf2, 0x4f, - 0x74, 0xba, 0x9f, 0xd3, 0x7e, 0xd9, 0x18, 0x16, 0xed, 0x45, 0x9b, 0x2d, 0x18, 0xbf, 0x5b, 0x8e, - 0x2d, 0x17, 0xd7, 0xec, 0x70, 0xb5, 0x36, 0x98, 0xe4, 0xc0, 0x6f, 0xa6, 0x49, 0xd5, 0x4c, 0xd7, - 0x72, 0x35, 0xc7, 0x98, 0xdd, 0xf1, 0x7d, 0x87, 0xaf, 0xf6, 0x02, 0x67, 0xad, 0x39, 0x86, 0xbc, - 0x07, 0xa9, 0x8b, 0xbe, 0xef, 0xa0, 0x93, 0x90, 0x76, 0x1b, 0x26, 0xf6, 0xf8, 0x2a, 0xfb, 0x64, - 0x31, 0xc4, 0x29, 0x12, 0x04, 0xa5, 0x61, 0x62, 0x85, 0xa1, 0xa0, 0x0a, 0x4c, 0x6f, 0x37, 0x4c, - 0x73, 0x4f, 0xad, 0x62, 0x7a, 0x09, 0x23, 0x38, 0xc6, 0x88, 0x77, 0x1d, 0x4d, 0x6c, 0x86, 0x10, - 0x93, 0x1d, 0xa7, 0x68, 0x0b, 0x14, 0x4b, 0x1c, 0x61, 0xac, 0x08, 0x1c, 0xf9, 0xf7, 0x13, 0x90, - 0x11, 0xac, 0x51, 0x01, 0x32, 0x1e, 0x36, 0xb1, 0xee, 0xdb, 0x2e, 0x3f, 0x5b, 0x16, 0xbc, 0x23, - 0x04, 0xc9, 0x1a, 0xbf, 0x55, 0x95, 0xbd, 0x78, 0x48, 0x21, 0x2f, 0x04, 0xe6, 0x34, 0xd8, 0x95, - 0x2a, 0x0a, 0x73, 0x1a, 0x3e, 0x9a, 0x84, 0x94, 0x63, 0x7b, 0x3e, 0xdb, 0xa0, 0xb8, 0x78, 0x48, - 0xa1, 0x6f, 0x28, 0x0f, 0x03, 0x55, 0x6c, 0x62, 0x9f, 0xed, 0x30, 0x11, 0x38, 0x7f, 0x47, 0x47, - 0x20, 0xed, 0x68, 0xbe, 0xbe, 0xc3, 0x8e, 0x58, 0x5f, 0x3c, 0xa4, 0xb0, 0x57, 0x84, 0x20, 0xb5, - 0x65, 0x57, 0xf7, 0xf8, 0xe1, 0x69, 0xfa, 0x8c, 0xce, 0xc2, 0x00, 0x8b, 0xf6, 0xe6, 0x53, 0xcf, - 0xc4, 0x40, 0x6c, 0x59, 0x95, 0xe8, 0xb2, 0xae, 0x91, 0x0a, 0xde, 0x22, 0x8d, 0x30, 0x74, 0x54, - 0x81, 0x09, 0xad, 0x5a, 0x35, 0xd8, 0xd9, 0x66, 0x75, 0xcb, 0xb0, 0xaa, 0x86, 0x55, 0xf3, 0xe8, - 0x2d, 0xa1, 0x4e, 0x66, 0x46, 0x21, 0x41, 0x99, 0xe3, 0xf3, 0xd3, 0xa2, 0xf4, 0x26, 0x98, 0x4a, - 0x85, 0x63, 0x77, 0x56, 0x86, 0x05, 0xb0, 0x6c, 0x57, 0xf7, 0xca, 0x59, 0x18, 0x74, 0x98, 0x00, - 0xf2, 0x79, 0x18, 0x6f, 0x91, 0x8a, 0x28, 0x76, 0xcd, 0xb0, 0xaa, 0xe2, 0x18, 0x23, 0x79, 0x26, - 0x30, 0xba, 0x0d, 0xc2, 0xf6, 0x39, 0xe8, 0x73, 0xf9, 0xa7, 0xa4, 0x8e, 0xae, 0x39, 0x1a, 0x71, - 0x4d, 0xcd, 0x31, 0xca, 0x59, 0xca, 0x9f, 0xb8, 0xd5, 0xba, 0xf4, 0xee, 0x39, 0xfe, 0x81, 0xed, - 0x60, 0x14, 0x6d, 0xb7, 0x36, 0x5b, 0xc3, 0x96, 0xd8, 0x6d, 0x20, 0x9f, 0x34, 0xc7, 0xf0, 0xa8, - 0x3b, 0x86, 0xdb, 0x32, 0xde, 0xf9, 0xc8, 0x33, 0xdd, 0xc8, 0x48, 0x2d, 0xce, 0xad, 0x2f, 0x05, - 0x57, 0xcf, 0xbe, 0x9a, 0x80, 0xe3, 0x11, 0x3f, 0x8e, 0x20, 0xb7, 0xba, 0x73, 0xa1, 0xbd, 0xc7, - 0xf7, 0xb0, 0xa9, 0x71, 0x19, 0x52, 0x04, 0x1f, 0x75, 0x39, 0x84, 0x99, 0xff, 0xa5, 0x7f, 0xf6, - 0x8f, 0x64, 0xea, 0x00, 0xed, 0xbb, 0x8e, 0x32, 0x29, 0x7f, 0xb8, 0x77, 0xfb, 0xe5, 0xc2, 0x1d, - 0x29, 0xef, 0xce, 0x99, 0xb1, 0xd9, 0x86, 0x1f, 0x4b, 0xc0, 0x74, 0xb3, 0x09, 0x48, 0x32, 0xf5, - 0x7c, 0xad, 0xee, 0x74, 0xba, 0xbd, 0x77, 0x1e, 0xb2, 0x9b, 0x02, 0x07, 0xe5, 0x61, 0xd0, 0xc3, - 0xba, 0x6d, 0x55, 0x3d, 0xea, 0x3d, 0x49, 0x45, 0xbc, 0xa2, 0x49, 0x48, 0x5b, 0x9a, 0x65, 0x7b, - 0xfc, 0xcc, 0x30, 0x7b, 0x29, 0xff, 0x25, 0xa9, 0xbf, 0xec, 0x36, 0x1a, 0x34, 0x25, 0xac, 0xf0, - 0xd0, 0x7e, 0x5b, 0x62, 0xec, 0x8e, 0x62, 0xa0, 0x42, 0x64, 0xff, 0x6b, 0xaa, 0x79, 0xff, 0xeb, - 0x19, 0x6c, 0x9a, 0x97, 0x2d, 0xfb, 0x86, 0xb5, 0x49, 0x68, 0x02, 0x93, 0xfc, 0xae, 0x04, 0x33, - 0xf4, 0xd6, 0x84, 0x5b, 0x37, 0x2c, 0x7f, 0xd6, 0x34, 0xb6, 0xbc, 0xd9, 0x2d, 0xc3, 0xf7, 0xd8, - 0xf5, 0x47, 0x6e, 0x93, 0xc9, 0x10, 0xa3, 0x48, 0x30, 0x8a, 0x04, 0x43, 0x3e, 0x0d, 0x99, 0xb2, - 0xe1, 0xcf, 0xb9, 0xae, 0xb6, 0x47, 0x73, 0x85, 0xe1, 0x0b, 0xa3, 0xd0, 0x67, 0x62, 0x11, 0x6c, - 0xe2, 0xba, 0x47, 0x77, 0x5e, 0x53, 0x0a, 0x7b, 0x29, 0x5f, 0xe9, 0x78, 0x1d, 0xf3, 0x7c, 0x44, - 0xd3, 0x88, 0x48, 0x91, 0x47, 0xd6, 0xf7, 0xed, 0xc4, 0x0d, 0xf4, 0xf9, 0x52, 0x0a, 0xee, 0x8e, - 0x20, 0xe8, 0xee, 0x9e, 0xe3, 0xd3, 0x71, 0xc1, 0xde, 0xe6, 0xca, 0x8c, 0x47, 0x94, 0x61, 0x9f, - 0x0b, 0x6d, 0x77, 0x03, 0xe5, 0x6d, 0x48, 0xaf, 0x13, 0xba, 0xf0, 0x5e, 0x29, 0xd3, 0x8e, 0xbd, - 0x10, 0x28, 0xbb, 0x39, 0x92, 0x60, 0x50, 0x43, 0x5c, 0x1a, 0x31, 0xb1, 0xb6, 0xcd, 0x0e, 0xe0, - 0x26, 0xe9, 0x06, 0x7c, 0x86, 0x00, 0xe8, 0x59, 0xdb, 0x49, 0x48, 0x6b, 0x0d, 0xb6, 0x77, 0x9c, - 0x3c, 0x31, 0xac, 0xb0, 0x17, 0xf9, 0x32, 0x0c, 0xf2, 0xfd, 0xaa, 0x36, 0xb7, 0x69, 0x8b, 0x90, - 0xa6, 0xc2, 0xf3, 0x9b, 0x05, 0xf9, 0x62, 0x8b, 0xf4, 0x45, 0x2a, 0xa4, 0xc2, 0xd0, 0xe4, 0x4b, - 0x90, 0x59, 0xb0, 0xeb, 0x86, 0x65, 0xc7, 0xb9, 0x65, 0x19, 0x37, 0x2a, 0x33, 0x19, 0x30, 0x58, - 0x9a, 0x63, 0x2f, 0xf4, 0xc6, 0x2e, 0x3d, 0x90, 0xcd, 0xf7, 0xbf, 0xf9, 0x9b, 0x3c, 0x0f, 0x83, - 0x94, 0xf7, 0x9a, 0x43, 0xfa, 0x37, 0x38, 0x0d, 0x97, 0xe5, 0xd7, 0x73, 0x38, 0xfb, 0x44, 0x28, - 0x2c, 0x82, 0x54, 0x55, 0xf3, 0x35, 0xae, 0x37, 0x7d, 0x96, 0xdf, 0x01, 0x19, 0xce, 0xc4, 0x43, - 0xa7, 0x20, 0x69, 0x3b, 0x62, 0x6c, 0x2d, 0x74, 0x52, 0x65, 0xcd, 0x29, 0xa7, 0xbe, 0x7e, 0x6b, - 0xfa, 0x90, 0x42, 0x90, 0xcb, 0x4a, 0x47, 0x7f, 0x39, 0xd7, 0xbf, 0xbf, 0xb0, 0x66, 0x02, 0x67, - 0xf9, 0x5c, 0x02, 0xa6, 0x22, 0x5f, 0xaf, 0x63, 0x97, 0x8c, 0xc8, 0x31, 0xd7, 0x47, 0x11, 0x21, - 0xf9, 0xf7, 0x0e, 0xee, 0xf2, 0x76, 0x48, 0xce, 0x39, 0x0e, 0x19, 0xc1, 0xd9, 0x4e, 0xb5, 0xcd, - 0xfc, 0x25, 0xa5, 0x04, 0xef, 0x74, 0x74, 0xb7, 0xb7, 0xfd, 0x1b, 0x9a, 0x1b, 0xdc, 0x59, 0x12, - 0xef, 0xf2, 0x93, 0x90, 0x9d, 0x27, 0x23, 0x98, 0xe5, 0x35, 0x68, 0xe8, 0x6c, 0x99, 0xb6, 0x7e, - 0x8d, 0x73, 0x60, 0x2f, 0xc4, 0xe0, 0x9a, 0xe3, 0xf0, 0xdb, 0xcd, 0xe4, 0xb1, 0x94, 0xfa, 0xde, - 0x67, 0xa7, 0xa5, 0xf2, 0x46, 0x47, 0x13, 0x3d, 0xd9, 0xbf, 0x89, 0xb8, 0x92, 0x81, 0x8d, 0x7e, - 0xfd, 0x28, 0x1c, 0x8f, 0x92, 0xb2, 0x8c, 0x13, 0xb1, 0x50, 0x2e, 0x62, 0x21, 0x0a, 0x6f, 0x6f, - 0x9f, 0x42, 0xb7, 0xcc, 0x5b, 0xe8, 0x9a, 0x87, 0x0a, 0xfb, 0x47, 0x76, 0xa1, 0x4b, 0x5f, 0xca, - 0x4f, 0xc2, 0xc8, 0xba, 0xe6, 0xfa, 0x1b, 0xd8, 0xbf, 0x88, 0xb5, 0x2a, 0x76, 0xe3, 0x81, 0x3d, - 0x22, 0x02, 0x1b, 0x41, 0x8a, 0x46, 0x2f, 0x73, 0x6c, 0xfa, 0x2c, 0xef, 0x40, 0x8a, 0x9e, 0x76, - 0x09, 0x82, 0x9e, 0x53, 0xb0, 0xa0, 0x27, 0xdd, 0xb5, 0xe7, 0x63, 0x8f, 0x93, 0xb0, 0x17, 0x74, - 0x5a, 0x84, 0x6e, 0x72, 0xff, 0xd0, 0xe5, 0xde, 0xce, 0x03, 0xd8, 0x84, 0xc1, 0x32, 0xe9, 0xed, - 0xa5, 0x85, 0x40, 0x10, 0x29, 0x14, 0x04, 0xad, 0xc0, 0x98, 0xa3, 0xb9, 0x3e, 0x3d, 0xe6, 0xbb, - 0x43, 0xb5, 0xe0, 0x99, 0x61, 0xba, 0xd8, 0xdc, 0x0f, 0xc5, 0x98, 0xb2, 0xbc, 0x95, 0x11, 0x27, - 0x0a, 0x94, 0xff, 0x53, 0x0a, 0x06, 0xb8, 0x31, 0xde, 0x0e, 0x83, 0xdc, 0x68, 0xb4, 0x41, 0x52, - 0xdb, 0xb5, 0xfa, 0x7e, 0x31, 0xf0, 0x51, 0xce, 0x4f, 0xd0, 0xa0, 0xfb, 0x21, 0xa3, 0xef, 0x68, - 0x86, 0xa5, 0x1a, 0xec, 0xbc, 0x6b, 0xb6, 0x3c, 0xf4, 0xf2, 0xad, 0xe9, 0xc1, 0x79, 0x02, 0x5b, - 0x5a, 0x50, 0x06, 0xe9, 0xc7, 0xa5, 0x2a, 0x49, 0x36, 0x3b, 0xd8, 0xa8, 0xed, 0xb0, 0x64, 0x93, - 0x54, 0xf8, 0x1b, 0x3a, 0x07, 0x29, 0xe2, 0x10, 0xfc, 0x12, 0x48, 0xa1, 0xa5, 0xfe, 0x08, 0x06, - 0xc6, 0x72, 0x86, 0x34, 0xfc, 0xb1, 0x6f, 0x4f, 0x4b, 0x0a, 0xa5, 0x40, 0xf3, 0x30, 0x62, 0x6a, - 0x9e, 0xaf, 0xd2, 0x20, 0x21, 0xcd, 0xa7, 0x29, 0x8b, 0xa3, 0xad, 0x06, 0xe1, 0x86, 0xe5, 0xa2, - 0x0f, 0x11, 0x2a, 0x06, 0xaa, 0xa2, 0x13, 0x90, 0xa3, 0x4c, 0x74, 0xbb, 0x5e, 0x37, 0x7c, 0x96, - 0xbe, 0x07, 0xa8, 0xdd, 0x47, 0x09, 0x7c, 0x9e, 0x82, 0x69, 0x12, 0x3f, 0x06, 0x59, 0x7a, 0xec, - 0x9c, 0xa2, 0xb0, 0x23, 0x56, 0x19, 0x02, 0xa0, 0x1f, 0x1f, 0x80, 0xb1, 0xeb, 0x9a, 0x69, 0x54, - 0x35, 0xdf, 0x76, 0x3d, 0x86, 0x92, 0x61, 0x5c, 0x42, 0x30, 0x45, 0x7c, 0x14, 0x26, 0xe9, 0xcf, - 0x18, 0x34, 0x63, 0x67, 0x29, 0x36, 0x22, 0xdf, 0xae, 0xc6, 0x29, 0xde, 0x46, 0x8a, 0x26, 0x6e, - 0x7c, 0x86, 0x0b, 0x14, 0x77, 0x24, 0x80, 0x52, 0xb4, 0xa3, 0x90, 0xd1, 0x1c, 0x87, 0x21, 0x0c, - 0xb1, 0xdf, 0x47, 0xd0, 0x1c, 0x87, 0x7e, 0x3a, 0x09, 0xe3, 0x54, 0x47, 0x17, 0x7b, 0x0d, 0xd3, - 0xe7, 0x4c, 0x86, 0x29, 0xce, 0x18, 0xf9, 0xa0, 0x30, 0x38, 0xc5, 0xbd, 0x17, 0x46, 0xf0, 0x75, - 0xa3, 0x8a, 0x2d, 0x1d, 0x33, 0xbc, 0x11, 0x8a, 0x37, 0x2c, 0x80, 0x14, 0xe9, 0x41, 0xc8, 0x39, - 0xae, 0xed, 0xd8, 0x1e, 0x76, 0x55, 0xad, 0x5a, 0x75, 0xb1, 0xe7, 0xe5, 0x47, 0x19, 0x3f, 0x01, - 0x9f, 0x63, 0x60, 0xf9, 0x61, 0x48, 0x2d, 0x68, 0xbe, 0x46, 0x72, 0x98, 0xbf, 0xcb, 0x86, 0x80, - 0x61, 0x85, 0x3c, 0xb6, 0x0d, 0xb7, 0xef, 0x25, 0x20, 0x75, 0xd5, 0xf6, 0x31, 0x7a, 0x3c, 0x32, - 0xee, 0x8c, 0xb6, 0xf3, 0xf1, 0x0d, 0xa3, 0x66, 0xe1, 0xea, 0x8a, 0x57, 0x8b, 0xdc, 0x1b, 0x0d, - 0x5d, 0x2c, 0x11, 0x73, 0xb1, 0x49, 0x48, 0xbb, 0x76, 0xc3, 0xaa, 0x8a, 0x13, 0x4b, 0xf4, 0x05, - 0x55, 0x20, 0x13, 0x78, 0x4e, 0xaa, 0x9b, 0xe7, 0x8c, 0x11, 0xcf, 0x21, 0x7e, 0xcd, 0x01, 0xca, - 0xe0, 0x16, 0x77, 0xa0, 0x32, 0x64, 0x83, 0x84, 0xc6, 0x3d, 0xb0, 0x37, 0x27, 0x0e, 0xc9, 0xd0, - 0x43, 0x30, 0x1e, 0xf8, 0x43, 0x60, 0x50, 0xe6, 0x85, 0xb9, 0xe0, 0x03, 0xb7, 0x68, 0xcc, 0xd5, - 0xf8, 0x1d, 0xd6, 0x41, 0xaa, 0x57, 0xe8, 0x6a, 0xec, 0x1e, 0xeb, 0x71, 0xc8, 0x7a, 0x46, 0xcd, - 0xd2, 0xfc, 0x86, 0x8b, 0xb9, 0x37, 0x86, 0x00, 0xf9, 0xe3, 0x09, 0x18, 0x60, 0xde, 0x1d, 0xb1, - 0x9b, 0xd4, 0xde, 0x6e, 0x89, 0x4e, 0x76, 0x4b, 0x1e, 0xdc, 0x6e, 0x73, 0x00, 0x81, 0x30, 0x1e, - 0xbf, 0x5a, 0x78, 0xac, 0x95, 0x11, 0x13, 0x71, 0xc3, 0xa8, 0xf1, 0xe0, 0x8d, 0x10, 0x05, 0x1e, - 0x94, 0x8e, 0xe4, 0xc9, 0xf3, 0x90, 0xdd, 0x32, 0x7c, 0x55, 0x23, 0xd5, 0x29, 0x35, 0xe1, 0xd0, - 0xa9, 0xa9, 0x62, 0xbb, 0x32, 0xb6, 0x28, 0x6a, 0x58, 0x25, 0xb3, 0xc5, 0x9f, 0xe4, 0xff, 0x20, - 0x91, 0xc1, 0x98, 0x37, 0x88, 0xe6, 0x60, 0x44, 0x28, 0xaa, 0x6e, 0x9b, 0x5a, 0x8d, 0x3b, 0xe3, - 0xdd, 0x1d, 0xb5, 0xbd, 0x60, 0x6a, 0x35, 0x65, 0x88, 0x2b, 0x48, 0x5e, 0xda, 0x77, 0x6c, 0xa2, - 0x43, 0xc7, 0xc6, 0x3c, 0x29, 0x79, 0x30, 0x4f, 0x8a, 0xf5, 0x79, 0xaa, 0xb9, 0xcf, 0xbf, 0x9c, - 0xa0, 0x45, 0x99, 0x63, 0x7b, 0x9a, 0xf9, 0x46, 0x84, 0xd8, 0x31, 0xc8, 0x3a, 0xb6, 0xa9, 0xb2, - 0x2f, 0xec, 0x68, 0x60, 0xc6, 0xb1, 0x4d, 0xa5, 0xc5, 0x8f, 0xd2, 0x77, 0x28, 0xfe, 0x06, 0xee, - 0x80, 0xd5, 0x06, 0x9b, 0xad, 0xe6, 0xc2, 0x30, 0x33, 0x05, 0x1f, 0x30, 0x1f, 0x25, 0x36, 0xa0, - 0x23, 0xb0, 0xd4, 0x3a, 0xc0, 0x33, 0xb1, 0x19, 0xa6, 0xc2, 0xf1, 0x08, 0x05, 0x1b, 0x5f, 0xda, - 0x55, 0xf3, 0x51, 0x3f, 0x57, 0x38, 0x9e, 0xfc, 0x4f, 0x25, 0xc8, 0x52, 0x55, 0x57, 0xb0, 0xaf, - 0xc5, 0x4c, 0x25, 0x1d, 0xdc, 0x54, 0x77, 0x03, 0x30, 0x36, 0x9e, 0x71, 0x13, 0xf3, 0x0e, 0xcc, - 0x52, 0xc8, 0x86, 0x71, 0x13, 0xa3, 0x33, 0x81, 0x5e, 0xc9, 0xfd, 0xf5, 0xe2, 0xa1, 0x28, 0xb4, - 0xbb, 0x0b, 0x06, 0xe9, 0x4f, 0x68, 0xec, 0xb2, 0xb3, 0xb1, 0x49, 0x7a, 0x6f, 0x76, 0x73, 0xd7, - 0x93, 0x9f, 0x83, 0xc1, 0xcd, 0x5d, 0x36, 0x95, 0x3a, 0x06, 0x59, 0xd7, 0xb6, 0xf9, 0xf8, 0xca, - 0xea, 0x9a, 0x0c, 0x01, 0xd0, 0xe1, 0x44, 0x4c, 0x1f, 0x12, 0xe1, 0xf4, 0x21, 0x9c, 0xff, 0x24, - 0x7b, 0x9a, 0xff, 0x9c, 0xfc, 0xb7, 0x12, 0x0c, 0x45, 0xc2, 0x10, 0x3d, 0x06, 0x87, 0xcb, 0xcb, - 0x6b, 0xf3, 0x97, 0xd5, 0xa5, 0x05, 0xf5, 0xc2, 0xf2, 0xdc, 0x62, 0x78, 0xc6, 0xbc, 0x70, 0xe4, - 0xc5, 0x97, 0x66, 0x50, 0x04, 0xf7, 0x8a, 0x75, 0x8d, 0xcc, 0x8f, 0xd1, 0x2c, 0x4c, 0xc6, 0x49, - 0xe6, 0xca, 0x1b, 0x95, 0xd5, 0xcd, 0x9c, 0x54, 0x38, 0xfc, 0xe2, 0x4b, 0x33, 0xe3, 0x11, 0x8a, - 0xb9, 0x2d, 0x0f, 0x5b, 0x7e, 0x2b, 0xc1, 0xfc, 0xda, 0xca, 0xca, 0xd2, 0x66, 0x2e, 0xd1, 0x42, - 0xc0, 0x13, 0xed, 0x83, 0x30, 0x1e, 0x27, 0x58, 0x5d, 0x5a, 0xce, 0x25, 0x0b, 0xe8, 0xc5, 0x97, - 0x66, 0x46, 0x23, 0xd8, 0xab, 0x86, 0x59, 0xc8, 0xfc, 0xf4, 0x17, 0xa6, 0x0e, 0xfd, 0xfc, 0x5f, - 0x9b, 0x92, 0x88, 0x66, 0x23, 0xb1, 0x50, 0x44, 0x0f, 0xc3, 0x5d, 0x1b, 0x4b, 0x8b, 0xab, 0x95, - 0x05, 0x75, 0x65, 0x63, 0x51, 0x65, 0x77, 0xeb, 0x03, 0xed, 0xc6, 0x5e, 0x7c, 0x69, 0x66, 0x88, - 0xab, 0xd4, 0x09, 0x7b, 0x5d, 0xa9, 0x5c, 0x5d, 0xdb, 0xac, 0xe4, 0x24, 0x86, 0xbd, 0xee, 0xe2, - 0xeb, 0xb6, 0xcf, 0x7e, 0x63, 0xe7, 0x51, 0x38, 0xda, 0x06, 0x3b, 0x50, 0x6c, 0xfc, 0xc5, 0x97, - 0x66, 0x46, 0xd6, 0x5d, 0xcc, 0xdc, 0x94, 0x52, 0x14, 0x21, 0xdf, 0x4a, 0xb1, 0xb6, 0xbe, 0xb6, - 0x31, 0xb7, 0x9c, 0x9b, 0x29, 0xe4, 0x5e, 0x7c, 0x69, 0x66, 0x58, 0xe4, 0x1c, 0x82, 0x1f, 0x6a, - 0x56, 0x7e, 0xba, 0xe3, 0xfc, 0xe5, 0x6c, 0xff, 0xf3, 0x17, 0x3f, 0xb6, 0xbc, 0xf1, 0xe7, 0x13, - 0x30, 0xd5, 0xb2, 0xe8, 0xc5, 0xd7, 0xbf, 0x3b, 0x2d, 0xf8, 0x94, 0x20, 0xb3, 0x20, 0x96, 0xd5, - 0xfb, 0x5d, 0xef, 0xf9, 0xb9, 0x3e, 0xd7, 0x7b, 0x46, 0x44, 0x4b, 0x62, 0xb9, 0xe7, 0x64, 0xf7, - 0xe5, 0x1e, 0x21, 0xff, 0x01, 0x56, 0x7b, 0x3e, 0x98, 0x84, 0xa9, 0xe8, 0xcf, 0x80, 0x89, 0x1f, - 0x00, 0xd3, 0x6d, 0x43, 0x98, 0x63, 0x22, 0xfa, 0xd3, 0x5f, 0xfc, 0x7b, 0x87, 0x19, 0xef, 0x22, - 0xa4, 0xe6, 0x6d, 0xc3, 0x22, 0xa6, 0xa8, 0x62, 0xcb, 0xae, 0xf3, 0xd5, 0x01, 0xf6, 0x82, 0xee, - 0x85, 0x01, 0xad, 0x6e, 0x37, 0x2c, 0x5f, 0x4c, 0x07, 0x48, 0xb2, 0xf8, 0xfd, 0x5b, 0xd3, 0xc9, - 0x25, 0xcb, 0x57, 0xf8, 0x27, 0x36, 0x81, 0x95, 0x2f, 0xc1, 0xe0, 0x02, 0xd6, 0x0f, 0xc2, 0x6b, - 0x01, 0xeb, 0x4d, 0xbc, 0x1e, 0x84, 0xcc, 0x92, 0xe5, 0xb3, 0xfb, 0xea, 0x77, 0x43, 0xd2, 0xb0, - 0x58, 0x35, 0xd3, 0xd4, 0x3e, 0x81, 0x13, 0xd4, 0x05, 0xac, 0x07, 0xa8, 0x55, 0xac, 0x37, 0xa3, - 0x12, 0xf6, 0x04, 0x5e, 0x5e, 0xf8, 0xbd, 0xff, 0x38, 0x75, 0xe8, 0x85, 0x97, 0xa7, 0x0e, 0x75, - 0x74, 0x55, 0xb9, 0xfb, 0x8f, 0x89, 0x05, 0xdd, 0xf0, 0xa1, 0xc7, 0xe0, 0x3e, 0x8e, 0xe3, 0xf9, - 0xda, 0x35, 0xc3, 0xaa, 0x05, 0x3d, 0xc1, 0xdf, 0x79, 0x67, 0x1c, 0xe1, 0x9d, 0x21, 0xa0, 0xfb, - 0xf6, 0x47, 0x61, 0xdf, 0x79, 0x7a, 0xf7, 0xf9, 0x77, 0x97, 0x40, 0x29, 0x74, 0xf1, 0x1c, 0xf9, - 0x23, 0x12, 0x8c, 0x5e, 0x34, 0x3c, 0xdf, 0x76, 0x0d, 0x5d, 0x33, 0xe9, 0xcd, 0x85, 0x33, 0xbd, - 0x0e, 0x91, 0x4d, 0x43, 0xc9, 0x53, 0x30, 0x70, 0x5d, 0x33, 0xd9, 0x6f, 0xc8, 0x25, 0xe9, 0x0f, - 0x2d, 0xb4, 0x37, 0x44, 0x31, 0x98, 0x23, 0x09, 0x06, 0x8c, 0x4c, 0xfe, 0xc5, 0x04, 0x8c, 0xd1, - 0x64, 0xeb, 0xb1, 0x9f, 0xe0, 0x21, 0xf3, 0xf1, 0x32, 0xa4, 0x5c, 0xcd, 0xe7, 0x6b, 0x58, 0xe5, - 0x22, 0xef, 0xe3, 0xfb, 0xbb, 0xf7, 0x5b, 0x91, 0xb8, 0x01, 0xa5, 0x45, 0x3f, 0x0e, 0x99, 0xba, - 0xb6, 0xab, 0x52, 0x3e, 0xcc, 0x15, 0xe7, 0xfa, 0xe3, 0x73, 0xfb, 0xd6, 0xf4, 0xd8, 0x9e, 0x56, - 0x37, 0x4b, 0xb2, 0xe0, 0x23, 0x2b, 0x83, 0x75, 0x6d, 0x97, 0x88, 0x88, 0x1c, 0x18, 0x23, 0x50, - 0x7d, 0x47, 0xb3, 0x6a, 0x98, 0x35, 0x42, 0x57, 0xe4, 0xca, 0x17, 0xfb, 0x6e, 0xe4, 0x48, 0xd8, - 0x48, 0x84, 0x9d, 0xac, 0x8c, 0xd4, 0xb5, 0xdd, 0x79, 0x0a, 0x20, 0x2d, 0x96, 0x32, 0x9f, 0xf8, - 0xec, 0xf4, 0x21, 0x1a, 0x37, 0xdf, 0x94, 0x00, 0x42, 0x8b, 0xa1, 0x1f, 0x87, 0x9c, 0x1e, 0xbc, - 0x51, 0x5a, 0x8f, 0xf7, 0xe1, 0x03, 0x9d, 0xfa, 0xa2, 0xc9, 0xde, 0xac, 0xc4, 0xfa, 0xc6, 0xad, - 0x69, 0x49, 0x19, 0xd3, 0x9b, 0xba, 0xe2, 0x3d, 0x30, 0xd4, 0x70, 0xaa, 0x9a, 0x8f, 0x55, 0x3a, - 0xe7, 0x4f, 0x74, 0x2d, 0xd7, 0xa6, 0x08, 0xaf, 0xdb, 0xb7, 0xa6, 0x11, 0x53, 0x2b, 0x42, 0x2c, - 0xd3, 0x22, 0x0e, 0x18, 0x84, 0x10, 0x44, 0x74, 0xfa, 0x1d, 0x09, 0x86, 0x16, 0x22, 0x27, 0x88, - 0xf2, 0x30, 0x58, 0xb7, 0x2d, 0xe3, 0x1a, 0x16, 0x9b, 0x6b, 0xe2, 0x15, 0x15, 0x20, 0xc3, 0x2e, - 0x73, 0xf9, 0x7b, 0x62, 0x65, 0x4e, 0xbc, 0x13, 0xaa, 0x1b, 0x78, 0xcb, 0x33, 0x44, 0x6f, 0x28, - 0xe2, 0x15, 0x5d, 0x80, 0x9c, 0x87, 0xf5, 0x86, 0x6b, 0xf8, 0x7b, 0xaa, 0x6e, 0x5b, 0xbe, 0xa6, - 0xf3, 0x5d, 0xb7, 0xf2, 0xb1, 0xdb, 0xb7, 0xa6, 0xef, 0x62, 0xb2, 0x36, 0x63, 0xc8, 0xca, 0x98, - 0x00, 0xcd, 0x33, 0x08, 0x69, 0xa1, 0x8a, 0x7d, 0xcd, 0x30, 0x3d, 0xb6, 0x39, 0xa7, 0x88, 0xd7, - 0x88, 0x2e, 0xff, 0x78, 0x10, 0xb2, 0x81, 0xb7, 0xa3, 0x1b, 0x90, 0xb3, 0x1d, 0xec, 0xc6, 0xe6, - 0x13, 0xb4, 0x9c, 0x2a, 0x2f, 0x87, 0x2d, 0x37, 0x63, 0xc8, 0xff, 0xef, 0xd6, 0xf4, 0x23, 0x3d, - 0x78, 0xd0, 0x55, 0xcd, 0xe4, 0x73, 0x11, 0x65, 0x4c, 0xf0, 0x10, 0x93, 0x93, 0x0b, 0xc4, 0x2f, - 0xc4, 0x2a, 0x84, 0xd3, 0xd8, 0x12, 0x2b, 0xc0, 0x31, 0x95, 0x9b, 0x31, 0x64, 0xe2, 0x01, 0x1c, - 0xb4, 0x4e, 0x21, 0x64, 0x02, 0xf1, 0x9c, 0x66, 0x98, 0xe2, 0x86, 0xab, 0xc2, 0xdf, 0xd0, 0x12, - 0x0c, 0x78, 0xbe, 0xe6, 0x37, 0x58, 0x0d, 0x99, 0x2e, 0x3f, 0xd6, 0xa3, 0xcc, 0x65, 0xdb, 0xaa, - 0x6e, 0x50, 0x42, 0x85, 0x33, 0x40, 0x17, 0x60, 0xc0, 0xb7, 0xaf, 0x61, 0x8b, 0x1b, 0xb5, 0xaf, - 0x88, 0xa7, 0x63, 0x14, 0xa3, 0x46, 0x3e, 0xe4, 0xaa, 0xd8, 0xc4, 0x35, 0x6a, 0x4a, 0x6f, 0x47, - 0x23, 0xf3, 0x54, 0xba, 0x55, 0x5a, 0x5e, 0xea, 0x3b, 0x2c, 0xb9, 0x81, 0x9a, 0xf9, 0xc9, 0xca, - 0x58, 0x00, 0xda, 0xa0, 0x10, 0x74, 0x39, 0x76, 0xf8, 0x8d, 0xff, 0x64, 0xdb, 0xbd, 0x9d, 0x62, - 0x2f, 0xe2, 0xe5, 0x62, 0x75, 0x2b, 0x7a, 0x74, 0xee, 0x02, 0xe4, 0x1a, 0xd6, 0x96, 0x4d, 0x37, - 0x51, 0x55, 0x3e, 0x71, 0xcb, 0x90, 0x7a, 0x26, 0xda, 0x6b, 0xcd, 0x18, 0xb2, 0x32, 0x16, 0x80, - 0x2e, 0xb2, 0xe9, 0x5d, 0x15, 0x46, 0x43, 0x2c, 0x1a, 0xba, 0xd9, 0xae, 0xa1, 0x7b, 0x0f, 0x0f, - 0xdd, 0xc3, 0xcd, 0xad, 0x84, 0xd1, 0x3b, 0x12, 0x00, 0x09, 0x19, 0xba, 0x08, 0x10, 0x26, 0x0c, - 0xba, 0xca, 0x35, 0x74, 0x4a, 0xee, 0x9e, 0x75, 0xc4, 0xca, 0x40, 0x48, 0x8b, 0xde, 0x07, 0x13, - 0x75, 0xc3, 0x52, 0x3d, 0x6c, 0x6e, 0xab, 0xdc, 0xc0, 0x84, 0x25, 0xfd, 0x51, 0x91, 0xf2, 0x72, - 0x7f, 0xfe, 0x70, 0xfb, 0xd6, 0x74, 0x81, 0x27, 0xd5, 0x56, 0x96, 0xb2, 0x32, 0x5e, 0x37, 0xac, - 0x0d, 0x6c, 0x6e, 0x2f, 0x04, 0xb0, 0xd2, 0xf0, 0x4f, 0x7f, 0x76, 0xfa, 0x50, 0x10, 0xc0, 0x06, - 0x0c, 0x87, 0x81, 0x85, 0x3d, 0xb4, 0x06, 0x59, 0x4d, 0xbc, 0xb0, 0xf5, 0xb0, 0x9e, 0x9d, 0x3d, - 0x12, 0xa0, 0x21, 0x0f, 0x96, 0x2b, 0x5e, 0xf8, 0xf7, 0x33, 0x92, 0xfc, 0x62, 0x02, 0x06, 0x16, - 0xae, 0xae, 0x6b, 0x86, 0x8b, 0x6e, 0xc2, 0x78, 0xe8, 0x6c, 0xf1, 0x4c, 0xb1, 0x72, 0xfb, 0xd6, - 0x74, 0xbe, 0xd9, 0x1f, 0xfb, 0x4c, 0x15, 0x73, 0xba, 0x2e, 0x24, 0x09, 0x83, 0x44, 0xe4, 0x8a, - 0x9b, 0x1d, 0x57, 0x3d, 0xa2, 0x6d, 0xb7, 0xa0, 0x1c, 0x20, 0x4d, 0xb5, 0x2c, 0xa2, 0x44, 0x12, - 0x67, 0x05, 0x06, 0x99, 0x2d, 0x3c, 0x54, 0x82, 0xb4, 0x43, 0x1e, 0xf8, 0x0e, 0xd4, 0x54, 0xc7, - 0x68, 0xa2, 0xf8, 0xc1, 0xba, 0x3c, 0x21, 0x91, 0x3f, 0x9f, 0x04, 0x58, 0xb8, 0x7a, 0x75, 0xd3, - 0x35, 0x1c, 0x13, 0xfb, 0x3f, 0x54, 0xbb, 0x7e, 0x48, 0x82, 0xc3, 0xa1, 0xd5, 0x3c, 0x57, 0x6f, - 0x32, 0xee, 0xd3, 0xb7, 0x6f, 0x4d, 0x1f, 0x6f, 0x36, 0x6e, 0x04, 0xed, 0x00, 0x06, 0x9e, 0x08, - 0x18, 0x6d, 0xb8, 0x7a, 0x7b, 0x39, 0xaa, 0x9e, 0x1f, 0xc8, 0x91, 0xec, 0x2c, 0x47, 0x04, 0xed, - 0x35, 0xc9, 0xb1, 0xe0, 0xf9, 0xad, 0x7d, 0xbd, 0x01, 0x43, 0x61, 0x1f, 0x79, 0x68, 0x01, 0x32, - 0x3e, 0x7f, 0xe6, 0x5d, 0x2e, 0x77, 0xee, 0x72, 0x41, 0xc6, 0xbb, 0x3d, 0xa0, 0x94, 0xff, 0x4d, - 0x02, 0x20, 0x8c, 0xea, 0x3f, 0xad, 0x11, 0x45, 0x86, 0x53, 0x3e, 0xf8, 0x25, 0x0f, 0x54, 0x40, - 0x73, 0xea, 0x48, 0x6f, 0xfd, 0x61, 0x02, 0x26, 0xae, 0x88, 0xcc, 0xff, 0x96, 0x85, 0xd1, 0x3a, - 0x0c, 0x62, 0xcb, 0x77, 0x0d, 0x6a, 0x62, 0xe2, 0xad, 0x8f, 0x76, 0xf2, 0xd6, 0x36, 0x56, 0xa3, - 0x3f, 0x9c, 0x23, 0x36, 0xe5, 0x38, 0x9b, 0x88, 0xad, 0x3f, 0x9a, 0x84, 0x7c, 0x27, 0x2a, 0x34, - 0x0f, 0x63, 0xba, 0x8b, 0x29, 0x40, 0x8d, 0xee, 0x00, 0x94, 0x0b, 0xe1, 0x4c, 0xa2, 0x09, 0x41, - 0x56, 0x46, 0x05, 0x84, 0xd7, 0x06, 0x35, 0x20, 0x65, 0x3e, 0x09, 0x19, 0x82, 0xd5, 0x63, 0x5d, - 0x2f, 0xf3, 0xe2, 0x40, 0x34, 0x12, 0x67, 0xc0, 0xaa, 0x83, 0xd1, 0x10, 0x4a, 0xcb, 0x83, 0xe7, - 0x61, 0xcc, 0xb0, 0x0c, 0xdf, 0xd0, 0x4c, 0x75, 0x4b, 0x33, 0x35, 0x4b, 0x3f, 0xc8, 0x2c, 0x89, - 0x0d, 0xe8, 0xbc, 0xd9, 0x26, 0x76, 0xb2, 0x32, 0xca, 0x21, 0x65, 0x06, 0x40, 0x17, 0x61, 0x50, - 0x34, 0x95, 0x3a, 0x50, 0x2d, 0x29, 0xc8, 0x23, 0x3d, 0xf2, 0x33, 0x49, 0x18, 0x57, 0x70, 0xf5, - 0xad, 0xae, 0xe8, 0xaf, 0x2b, 0x56, 0x00, 0x58, 0x22, 0x21, 0x23, 0xc9, 0x01, 0x7a, 0x83, 0xa4, - 0xa2, 0x2c, 0xe3, 0xb0, 0xe0, 0xf9, 0x91, 0xfe, 0xf8, 0xa3, 0x24, 0x0c, 0x47, 0xfb, 0xe3, 0xad, - 0x21, 0xfe, 0x47, 0x67, 0x88, 0x47, 0x4b, 0x61, 0x6a, 0x4c, 0xf1, 0xdf, 0x3f, 0xed, 0x90, 0x1a, - 0x5b, 0x42, 0xaa, 0x73, 0x4e, 0xfc, 0x5f, 0x09, 0x18, 0x58, 0xd7, 0x5c, 0xad, 0xee, 0x21, 0xbd, - 0x65, 0x62, 0x23, 0xf6, 0x57, 0x5a, 0x7e, 0xe1, 0x9a, 0x2f, 0x8a, 0x75, 0x99, 0xd7, 0x7c, 0xa2, - 0xcd, 0xbc, 0xe6, 0x9d, 0x30, 0x5a, 0xd7, 0x76, 0x23, 0x5b, 0xfe, 0xb4, 0x33, 0x47, 0xca, 0x47, - 0x43, 0x2e, 0xf1, 0xef, 0x6c, 0xb9, 0x26, 0x3c, 0x07, 0x80, 0xce, 0xc2, 0x10, 0xc1, 0x08, 0x47, - 0x09, 0x42, 0x7e, 0x24, 0x5c, 0x17, 0x89, 0x7c, 0x94, 0x15, 0xa8, 0x6b, 0xbb, 0x15, 0xf6, 0x82, - 0x96, 0x01, 0xed, 0x04, 0x4b, 0x73, 0x6a, 0x68, 0x4a, 0x42, 0x7f, 0xf7, 0xed, 0x5b, 0xd3, 0x47, - 0x19, 0x7d, 0x2b, 0x8e, 0xac, 0x8c, 0x87, 0x40, 0xc1, 0xed, 0x34, 0x00, 0xd1, 0x4b, 0x65, 0x2b, - 0xb5, 0x6c, 0x76, 0x7d, 0xf8, 0xf6, 0xad, 0xe9, 0x71, 0xc6, 0x25, 0xfc, 0x26, 0x2b, 0x59, 0xf2, - 0xb2, 0x40, 0x9e, 0x23, 0x86, 0xff, 0x82, 0x04, 0x28, 0x1c, 0x83, 0x82, 0x7f, 0xed, 0x70, 0x11, - 0x20, 0x32, 0x49, 0x93, 0xf6, 0x9f, 0xf7, 0x85, 0xf4, 0x62, 0xde, 0x17, 0x09, 0xdd, 0x27, 0xc3, - 0x7c, 0x9d, 0xe0, 0xfd, 0xd8, 0x66, 0x59, 0xbb, 0x38, 0x6f, 0x1b, 0x82, 0xba, 0x4d, 0x82, 0xfe, - 0xe7, 0x12, 0x1c, 0x6d, 0xf1, 0xa6, 0x40, 0xd8, 0x3f, 0x03, 0xc8, 0x8d, 0x7c, 0xe4, 0x3f, 0x64, - 0xc7, 0x84, 0xee, 0xdb, 0x39, 0xc7, 0xdd, 0x96, 0x81, 0xe0, 0xce, 0x0d, 0x39, 0x6c, 0x5d, 0xfc, - 0x9f, 0x48, 0x30, 0x19, 0x6d, 0x3e, 0x50, 0x64, 0x15, 0x86, 0xa3, 0xad, 0x73, 0x15, 0xee, 0xeb, - 0x45, 0x05, 0x2e, 0x7d, 0x8c, 0x1e, 0x3d, 0x1d, 0x86, 0x2a, 0x5b, 0xbc, 0x7d, 0xac, 0x67, 0x6b, - 0x08, 0x99, 0x9a, 0x43, 0x96, 0x69, 0xf0, 0x27, 0x12, 0xa4, 0xd6, 0x6d, 0xdb, 0x44, 0x36, 0x8c, - 0x5b, 0xb6, 0xaf, 0x12, 0xcf, 0xc2, 0x55, 0x95, 0xaf, 0xf1, 0xb0, 0x55, 0xdd, 0xf9, 0xfe, 0x8c, - 0xf4, 0xfd, 0x5b, 0xd3, 0xad, 0xac, 0x94, 0x31, 0xcb, 0xf6, 0xcb, 0x14, 0xb2, 0xc9, 0x56, 0x80, - 0xde, 0x07, 0x23, 0xf1, 0xc6, 0xd8, 0x8a, 0xd7, 0x33, 0x7d, 0x37, 0x16, 0x67, 0x73, 0xfb, 0xd6, - 0xf4, 0x64, 0x18, 0x31, 0x01, 0x58, 0x56, 0x86, 0xb7, 0x22, 0xad, 0x97, 0x32, 0x44, 0xfb, 0x3f, - 0xfe, 0xec, 0xb4, 0x54, 0xbe, 0xd0, 0x71, 0xf7, 0xe1, 0xe1, 0x7d, 0x45, 0xd8, 0x0d, 0xb6, 0x19, - 0xe2, 0xfb, 0x10, 0x9f, 0x39, 0x0f, 0x72, 0x87, 0x7d, 0x08, 0xf6, 0x4f, 0x5f, 0xf6, 0xdf, 0x85, - 0xe8, 0xe3, 0x3f, 0xca, 0x74, 0xda, 0xb1, 0xd8, 0xef, 0x44, 0x7b, 0xa1, 0xa7, 0x3d, 0x12, 0x79, - 0x17, 0x8e, 0x3c, 0x4d, 0xda, 0x0e, 0xd3, 0xa4, 0xf8, 0xdf, 0x34, 0x47, 0x82, 0xb5, 0x44, 0x89, - 0xff, 0x67, 0x0b, 0xb1, 0x30, 0x08, 0xa1, 0x7c, 0x3c, 0x41, 0xdc, 0x5f, 0xec, 0xf8, 0x2f, 0x6f, - 0x8a, 0x91, 0xff, 0x77, 0xa3, 0x44, 0x28, 0xe5, 0x5f, 0x90, 0xe0, 0xae, 0x96, 0xa6, 0x79, 0x54, - 0x2d, 0x02, 0x44, 0xf2, 0xbc, 0xd4, 0xdf, 0x2e, 0x46, 0x84, 0x94, 0x30, 0x6a, 0x11, 0xf6, 0x81, - 0xae, 0xc2, 0x32, 0x29, 0x62, 0xd2, 0x3e, 0x0f, 0x87, 0xe3, 0xc2, 0x0a, 0x33, 0x3d, 0x0b, 0xa3, - 0xf1, 0xf9, 0x0c, 0x2f, 0x72, 0x0e, 0xb0, 0x1a, 0x35, 0x12, 0x9b, 0xd3, 0xc8, 0x6a, 0x73, 0xd7, - 0x04, 0xe6, 0xa9, 0x40, 0x36, 0x40, 0xe5, 0x19, 0xa7, 0x67, 0xeb, 0x84, 0x94, 0xf2, 0xd7, 0x24, - 0x98, 0x89, 0xb7, 0x10, 0x0e, 0x0b, 0xde, 0xeb, 0xae, 0xdf, 0x1d, 0x73, 0xa4, 0xef, 0x49, 0x70, - 0xcf, 0x3e, 0x6a, 0x70, 0x9b, 0xdd, 0x84, 0xc9, 0xc8, 0x78, 0x23, 0x6e, 0xbc, 0x08, 0xe7, 0x3a, - 0xd9, 0x7d, 0xa0, 0x0c, 0xd2, 0xeb, 0x31, 0x62, 0xc7, 0x2f, 0x7d, 0x7b, 0x7a, 0xa2, 0xf5, 0x9b, - 0xa7, 0x4c, 0xb4, 0x8e, 0x11, 0x77, 0xd0, 0x0b, 0x7f, 0x57, 0x82, 0x07, 0xe3, 0xaa, 0xb6, 0x99, - 0x95, 0xbe, 0x89, 0xba, 0xee, 0xdf, 0x49, 0x70, 0xb2, 0x17, 0x7d, 0x78, 0x1f, 0x6e, 0xc1, 0x44, - 0x58, 0x28, 0x36, 0x77, 0xe1, 0x43, 0x7d, 0x4c, 0xf7, 0x79, 0x2c, 0xa0, 0x80, 0xdb, 0xeb, 0xd0, - 0x57, 0xff, 0x42, 0xe2, 0xf1, 0x1b, 0x75, 0x93, 0xa0, 0x63, 0xe2, 0x13, 0x9f, 0x3e, 0x3b, 0x26, - 0x32, 0xf9, 0x19, 0x89, 0x4d, 0x7e, 0xda, 0x74, 0x79, 0xe2, 0x0e, 0x65, 0xa3, 0xeb, 0x3c, 0x5b, - 0xb7, 0xa9, 0x3c, 0xdf, 0x03, 0x13, 0x6d, 0x42, 0x8b, 0x27, 0xa6, 0x3e, 0x22, 0x4b, 0x41, 0xad, - 0xc1, 0x23, 0xff, 0x6b, 0x09, 0xa6, 0x69, 0xc3, 0x6d, 0xba, 0xf1, 0xcd, 0x6c, 0xcf, 0x3a, 0xcf, - 0xbd, 0x6d, 0xd5, 0xe2, 0x86, 0x5d, 0x82, 0x01, 0xe6, 0xa1, 0xdc, 0x96, 0x07, 0x70, 0x71, 0xce, - 0x20, 0xcc, 0xf5, 0x0b, 0x42, 0xbf, 0xf6, 0x09, 0xe3, 0x75, 0xb2, 0xe3, 0x9d, 0x4a, 0x18, 0xdf, - 0x14, 0xb9, 0xbe, 0xbd, 0x1a, 0xdc, 0x6e, 0xfa, 0x1d, 0xcb, 0xf5, 0xcc, 0x88, 0x6f, 0x50, 0x52, - 0x0f, 0x74, 0xea, 0x92, 0xd4, 0x7f, 0xc4, 0xfb, 0x28, 0x48, 0xea, 0x5d, 0xf4, 0x79, 0x33, 0x26, - 0xf5, 0x3f, 0x49, 0xc0, 0x51, 0xaa, 0x5b, 0x74, 0xf6, 0xf5, 0x06, 0xf4, 0x8d, 0x0a, 0xc8, 0x73, - 0x75, 0xf5, 0x4e, 0xe5, 0xa2, 0x9c, 0xe7, 0xea, 0x57, 0x63, 0x23, 0xba, 0x0a, 0xa8, 0xea, 0xf9, - 0xcd, 0x0d, 0x24, 0x0f, 0xdc, 0x40, 0xd5, 0xf3, 0xaf, 0xee, 0x53, 0x32, 0xa4, 0x0e, 0xec, 0x5d, - 0xdf, 0x90, 0xa0, 0xd0, 0xae, 0x07, 0xb8, 0x37, 0x19, 0x70, 0x24, 0xb6, 0xb0, 0xd0, 0xec, 0x50, - 0x0f, 0xf7, 0x32, 0x9d, 0x6e, 0x0a, 0xff, 0xc3, 0x2e, 0x7e, 0x5d, 0x13, 0xc0, 0x6f, 0x88, 0x21, - 0x2e, 0x08, 0x98, 0xd6, 0xd9, 0xd8, 0x8f, 0x7e, 0xd8, 0xff, 0x4a, 0xcb, 0x08, 0xf3, 0xa6, 0x98, - 0xd8, 0x7d, 0x4b, 0x82, 0xa9, 0x0e, 0x62, 0xbf, 0x99, 0xcb, 0x8b, 0x9d, 0x8e, 0x2e, 0x75, 0xa7, - 0x67, 0x91, 0xa7, 0x79, 0x3c, 0xc6, 0x0f, 0x2f, 0x46, 0x56, 0x11, 0xda, 0xdd, 0x8a, 0x91, 0xdf, - 0x05, 0xc7, 0xda, 0x52, 0x71, 0xd9, 0x4a, 0x90, 0xda, 0x31, 0x3c, 0x9f, 0x8b, 0x75, 0x7f, 0x27, - 0xb1, 0x9a, 0xa8, 0x29, 0x8d, 0x8c, 0x20, 0x47, 0x59, 0xaf, 0xdb, 0xb6, 0xc9, 0xc5, 0x90, 0x2f, - 0xc3, 0x78, 0x04, 0xc6, 0x1b, 0x39, 0x03, 0x29, 0xc7, 0xe6, 0x17, 0x4d, 0x87, 0x4e, 0x1d, 0xef, - 0xd4, 0x08, 0xa1, 0xe1, 0x6a, 0x53, 0x7c, 0x79, 0x12, 0x10, 0x63, 0x46, 0x57, 0xbf, 0x45, 0x13, - 0x1b, 0x30, 0x11, 0x83, 0xf2, 0x46, 0x7e, 0x0c, 0x06, 0x1c, 0x0a, 0xe1, 0xcd, 0x74, 0x3c, 0x36, - 0xc1, 0xe8, 0x44, 0xd9, 0xc6, 0x68, 0x4e, 0x7d, 0xff, 0x30, 0xa4, 0x29, 0x57, 0xf4, 0x49, 0x09, - 0x20, 0xb2, 0x96, 0x5d, 0xec, 0xc4, 0xa6, 0xfd, 0x6a, 0x4e, 0x61, 0xb6, 0x67, 0x7c, 0x5e, 0x77, - 0x9f, 0xfc, 0xa9, 0x7f, 0xf5, 0xdd, 0x9f, 0x4d, 0xdc, 0x87, 0xe4, 0xd9, 0x0e, 0xeb, 0x48, 0x91, - 0x60, 0xfc, 0xa2, 0x14, 0x3d, 0x5d, 0xf7, 0x48, 0x6f, 0x4d, 0x09, 0xc9, 0x8a, 0xbd, 0xa2, 0x73, - 0xc1, 0xce, 0x53, 0xc1, 0x9e, 0x40, 0x8f, 0x77, 0x17, 0x6c, 0xf6, 0xbd, 0xf1, 0xe8, 0x7a, 0x3f, - 0xfa, 0x96, 0x04, 0x93, 0xed, 0x96, 0x09, 0xd0, 0xb9, 0xde, 0xa4, 0x68, 0x2d, 0xc8, 0x0a, 0x4f, - 0x1e, 0x80, 0x92, 0xab, 0xb2, 0x48, 0x55, 0x99, 0x43, 0x4f, 0x1d, 0x40, 0x95, 0xd9, 0xc8, 0xe8, - 0x87, 0xfe, 0xaf, 0x04, 0x77, 0xef, 0x3b, 0x85, 0x46, 0x73, 0xbd, 0x49, 0xb9, 0x4f, 0xe5, 0x59, - 0x28, 0xbf, 0x16, 0x16, 0x5c, 0xe3, 0xa7, 0xa9, 0xc6, 0x97, 0xd1, 0xd2, 0x41, 0x34, 0x0e, 0xcb, - 0xc4, 0xa8, 0xee, 0xbf, 0x2d, 0xc5, 0x0e, 0x98, 0xec, 0xef, 0x4e, 0x2d, 0x73, 0xc7, 0x2e, 0x81, - 0xd1, 0x3a, 0x25, 0x90, 0x9f, 0xa5, 0x2a, 0x28, 0x68, 0xfd, 0x35, 0x76, 0xda, 0xec, 0x7b, 0xe3, - 0x83, 0xca, 0xfb, 0xd1, 0xff, 0x96, 0xda, 0x9f, 0xe8, 0x38, 0xbb, 0xaf, 0x88, 0x9d, 0xe7, 0xc5, - 0x85, 0x73, 0xfd, 0x13, 0x72, 0x25, 0xeb, 0x54, 0xc9, 0x1a, 0xc2, 0x77, 0x5a, 0xc9, 0xb6, 0x9d, - 0x88, 0x7e, 0x47, 0x82, 0xc9, 0x76, 0x33, 0xba, 0x2e, 0x61, 0xb9, 0xcf, 0x5c, 0xb6, 0x4b, 0x58, - 0xee, 0x37, 0x7d, 0x94, 0x7f, 0x8c, 0x2a, 0x7f, 0x06, 0x9d, 0xee, 0xa4, 0xfc, 0xbe, 0xbd, 0x48, - 0x62, 0x71, 0xdf, 0x99, 0x4f, 0x97, 0x58, 0xec, 0x65, 0x16, 0xd8, 0x25, 0x16, 0x7b, 0x9a, 0x78, - 0x75, 0x8f, 0xc5, 0x40, 0xb3, 0x1e, 0xbb, 0xd1, 0x43, 0x5f, 0x95, 0x60, 0x24, 0x56, 0x97, 0xa3, - 0xc7, 0xf6, 0x15, 0xb4, 0xdd, 0x2c, 0xaa, 0x70, 0xaa, 0x1f, 0x12, 0xae, 0xcb, 0x12, 0xd5, 0x65, - 0x1e, 0xcd, 0x1d, 0x44, 0x17, 0x37, 0x26, 0xf1, 0x37, 0x24, 0x98, 0x68, 0x53, 0xc2, 0x76, 0x89, - 0xc2, 0xce, 0xa5, 0x7b, 0xe1, 0x5c, 0xff, 0x84, 0x5c, 0xab, 0x0b, 0x54, 0xab, 0x77, 0xa2, 0x77, - 0x1c, 0x44, 0xab, 0xc8, 0xf8, 0x7c, 0x2b, 0xdc, 0x31, 0x8e, 0xb4, 0x83, 0xce, 0xf4, 0x29, 0x98, - 0x50, 0xe8, 0x6c, 0xdf, 0x74, 0x5c, 0x9f, 0x67, 0xa8, 0x3e, 0x4f, 0xa3, 0xb5, 0xd7, 0xa6, 0x4f, - 0xeb, 0xb0, 0xfe, 0xe5, 0xd6, 0xcb, 0x33, 0xfb, 0x7b, 0x51, 0xdb, 0x62, 0xb5, 0xf0, 0x78, 0x5f, - 0x34, 0x5c, 0xa9, 0x73, 0x54, 0xa9, 0x53, 0xe8, 0xd1, 0x4e, 0x4a, 0x45, 0x8e, 0x05, 0x18, 0xd6, - 0xb6, 0x3d, 0xfb, 0x5e, 0x56, 0x02, 0xbf, 0x1f, 0xfd, 0xa4, 0xd8, 0x92, 0x3d, 0xb1, 0x6f, 0xbb, - 0x91, 0x3a, 0xb6, 0xf0, 0x60, 0x0f, 0x98, 0x5c, 0xae, 0xfb, 0xa8, 0x5c, 0x53, 0xe8, 0x78, 0x27, - 0xb9, 0x48, 0x2d, 0x8b, 0x3e, 0x22, 0x05, 0xa7, 0x38, 0x4e, 0xee, 0xcf, 0x3b, 0x5a, 0xec, 0x16, - 0x1e, 0xea, 0x09, 0x97, 0x4b, 0x72, 0x3f, 0x95, 0x64, 0x06, 0x4d, 0x75, 0x94, 0x84, 0x95, 0xbe, - 0x77, 0x7a, 0x83, 0xf6, 0x13, 0x13, 0x30, 0xdd, 0xa1, 0x45, 0x7f, 0xf7, 0x40, 0x77, 0xc4, 0xba, - 0x5c, 0xe2, 0xea, 0x71, 0xcf, 0xf5, 0xd5, 0x14, 0xa0, 0x15, 0xaf, 0x36, 0xef, 0x62, 0xf6, 0x0f, - 0x83, 0x78, 0x38, 0x36, 0xdd, 0x59, 0x90, 0x5e, 0xd3, 0x9d, 0x85, 0x95, 0xd8, 0x2d, 0x80, 0x44, - 0x7f, 0x77, 0x8f, 0x7a, 0xbe, 0x0a, 0x90, 0x7c, 0x43, 0xae, 0x02, 0xb4, 0x3f, 0x4b, 0x96, 0xfa, - 0x21, 0x1e, 0x69, 0x4d, 0xbf, 0x31, 0x47, 0x5a, 0x8f, 0xc0, 0x00, 0xbf, 0x24, 0xc4, 0xfe, 0x7f, - 0x3b, 0x7f, 0x43, 0x4f, 0x88, 0xff, 0x66, 0x3d, 0xd8, 0xdb, 0xf1, 0x1c, 0x86, 0xcd, 0x0f, 0x82, - 0x7c, 0x25, 0x09, 0xb9, 0x15, 0xaf, 0x56, 0xa9, 0x1a, 0xfe, 0xeb, 0xe4, 0x7b, 0x4e, 0xe7, 0x53, - 0xc0, 0xf3, 0xb7, 0x6f, 0x4d, 0x8f, 0x32, 0x93, 0xdd, 0x49, 0x43, 0xd5, 0x61, 0xac, 0xe9, 0xbe, - 0x1d, 0x77, 0xcd, 0x85, 0x83, 0x5c, 0xfb, 0x6b, 0x62, 0x25, 0xd3, 0x83, 0x9b, 0x91, 0x00, 0x41, - 0xbb, 0xed, 0xa3, 0x81, 0x9d, 0x34, 0xba, 0xf8, 0x7a, 0x5e, 0x8a, 0x61, 0x5d, 0xf8, 0xb5, 0x04, - 0x0c, 0xad, 0x78, 0xa2, 0xa8, 0xc3, 0x7f, 0x6a, 0x8f, 0x7c, 0x9f, 0x0d, 0x2e, 0x36, 0x27, 0x7b, - 0x0b, 0x84, 0xf8, 0x65, 0xe7, 0x6f, 0x27, 0x69, 0x1e, 0x2e, 0xe3, 0x9a, 0x61, 0x05, 0x65, 0x25, - 0x7e, 0xeb, 0xe4, 0xea, 0x8f, 0xd0, 0xc9, 0xd5, 0xb0, 0x87, 0x53, 0x07, 0xe9, 0xe1, 0xdf, 0x4a, - 0xc0, 0xc8, 0x8a, 0x57, 0xbb, 0x62, 0x55, 0xdf, 0x0a, 0x95, 0xd7, 0x12, 0x2a, 0x77, 0xbc, 0x34, - 0xfb, 0x54, 0xa6, 0xe3, 0x1d, 0xfe, 0x1a, 0xb6, 0xb0, 0x67, 0x78, 0x07, 0xaa, 0xcf, 0x7a, 0xab, - 0xbf, 0xbe, 0x95, 0x86, 0xe1, 0x45, 0xd6, 0xca, 0x86, 0x4f, 0x9c, 0xe2, 0x35, 0xad, 0xd1, 0x22, - 0x8f, 0xff, 0xf8, 0x19, 0xfd, 0xfd, 0x3b, 0xd5, 0xb1, 0x6f, 0x60, 0xb1, 0x8c, 0xbf, 0xd4, 0x77, - 0x61, 0xc4, 0x2f, 0x93, 0x36, 0xf3, 0x93, 0xd9, 0xef, 0xa8, 0x6d, 0x12, 0xc8, 0x3a, 0x01, 0xa0, - 0x0f, 0x4a, 0x70, 0x98, 0x62, 0x85, 0xee, 0x42, 0x31, 0xc5, 0xe5, 0x97, 0x8e, 0xc5, 0xfc, 0xb2, - 0x16, 0xd9, 0x99, 0xa3, 0xbc, 0xca, 0xf7, 0xf1, 0xb3, 0xd8, 0xc7, 0x23, 0x8d, 0x37, 0xb3, 0x95, - 0x95, 0x09, 0xb3, 0x85, 0xd2, 0x6b, 0xda, 0xcf, 0x49, 0x1d, 0x7c, 0x3f, 0xe7, 0x12, 0x29, 0x40, - 0x82, 0x49, 0x78, 0x3e, 0xdd, 0xe5, 0xbe, 0x59, 0xf3, 0xa6, 0x6f, 0x94, 0x18, 0x7d, 0x58, 0x82, - 0xc3, 0x6d, 0xd7, 0x27, 0xe8, 0x3f, 0x90, 0xec, 0x73, 0x53, 0xb9, 0xc9, 0x38, 0x6d, 0xf9, 0xca, - 0xca, 0x64, 0xa3, 0xdd, 0x42, 0xcf, 0x3a, 0x8c, 0xc4, 0xd6, 0x16, 0xf2, 0xe2, 0xdf, 0xc0, 0xf6, - 0x7e, 0x3a, 0x38, 0xce, 0x00, 0x15, 0x20, 0x83, 0x77, 0x1d, 0xdb, 0xf5, 0x71, 0x95, 0x5e, 0x41, - 0xce, 0x28, 0xc1, 0xbb, 0x7c, 0x03, 0x50, 0x6b, 0xe7, 0xa2, 0xcb, 0x30, 0x18, 0x4f, 0x73, 0x07, - 0xd8, 0x5b, 0x12, 0x1c, 0xd0, 0x24, 0xa4, 0x43, 0xff, 0x4e, 0x2a, 0xec, 0xe5, 0x4e, 0x27, 0x87, - 0xff, 0x1f, 0x00, 0x00, 0xff, 0xff, 0xbc, 0x8f, 0x19, 0xeb, 0x6f, 0x91, 0x00, 0x00, + 0xcc, 0x92, 0x00, 0x6d, 0x9f, 0xa3, 0xc4, 0x8f, 0xc6, 0x6a, 0x53, 0x3b, 0x8f, 0xd3, 0xda, 0x8e, + 0xe5, 0xfa, 0xd1, 0xd6, 0xa9, 0xd3, 0x36, 0x49, 0x9d, 0xa6, 0x4d, 0xd3, 0xd3, 0x3a, 0xad, 0x93, + 0x38, 0x6d, 0xd3, 0x63, 0x9f, 0xba, 0x6d, 0x9a, 0xd3, 0xd2, 0xa9, 0xec, 0xd3, 0x3a, 0xae, 0xdb, + 0xa4, 0xac, 0xfa, 0xd4, 0x8f, 0xe4, 0x7c, 0xaf, 0x79, 0xec, 0x03, 0xbb, 0x0b, 0x51, 0xb2, 0x75, + 0xa2, 0x5f, 0x98, 0xb9, 0x73, 0xef, 0xfd, 0xee, 0xbd, 0xdf, 0xbd, 0xf7, 0xbb, 0xdf, 0x6b, 0x01, + 0x5f, 0x4d, 0xc0, 0x49, 0xdd, 0xf6, 0xea, 0xb6, 0x37, 0xbb, 0xa5, 0x79, 0x78, 0xf6, 0xf9, 0x06, + 0x76, 0xf7, 0x66, 0xaf, 0x3f, 0xb6, 0x85, 0x7d, 0xed, 0xb1, 0x59, 0x47, 0xab, 0x19, 0x96, 0xe6, + 0x1b, 0xb6, 0x55, 0x74, 0x5c, 0xdb, 0xb7, 0xd1, 0x51, 0x86, 0x5b, 0x24, 0xb8, 0x45, 0x8a, 0x5b, + 0xe4, 0xb8, 0xb2, 0x05, 0x43, 0xeb, 0x5a, 0x0d, 0x2b, 0xf8, 0xf9, 0x06, 0xf6, 0x7c, 0x94, 0x83, + 0xe4, 0x35, 0xbc, 0x97, 0x97, 0x66, 0xa4, 0x13, 0xc3, 0x0a, 0x79, 0x44, 0x47, 0x60, 0xc0, 0xde, + 0xde, 0xf6, 0xb0, 0x9f, 0x4f, 0xcc, 0x48, 0x27, 0x52, 0x0a, 0x7f, 0x43, 0x93, 0x90, 0x36, 0x8d, + 0xba, 0xe1, 0xe7, 0x93, 0x14, 0xcc, 0x5e, 0xd0, 0x34, 0x0c, 0xe9, 0x76, 0xc3, 0xf2, 0x55, 0xdf, + 0xf6, 0x35, 0x33, 0x9f, 0x9a, 0x91, 0x4e, 0x64, 0x14, 0xa0, 0xa0, 0x4d, 0x02, 0x91, 0x9f, 0x82, + 0x61, 0xd6, 0x9e, 0xe7, 0xd8, 0x96, 0x87, 0xd1, 0x51, 0xc8, 0x58, 0x78, 0xd7, 0x57, 0xc3, 0x56, + 0x07, 0xc9, 0xfb, 0x65, 0xbc, 0x47, 0x5a, 0x60, 0x5c, 0x58, 0xc3, 0xec, 0xa5, 0x5c, 0xfe, 0xda, + 0xcb, 0x53, 0xd2, 0xd7, 0x5f, 0x9e, 0x92, 0xfe, 0xe0, 0xe5, 0x29, 0xe9, 0xe3, 0xdf, 0x9e, 0x3a, + 0xf4, 0xf5, 0x6f, 0x4f, 0x1d, 0xfa, 0xbd, 0x6f, 0x4f, 0x1d, 0x7a, 0xcf, 0x89, 0x9a, 0xe1, 0xef, + 0x34, 0xb6, 0x8a, 0xba, 0x5d, 0x9f, 0xe5, 0xc6, 0x61, 0x7f, 0x1e, 0xf1, 0xaa, 0xd7, 0x66, 0xfd, + 0x3d, 0x07, 0x7b, 0xcc, 0x50, 0x5b, 0x03, 0xd4, 0x2c, 0x8f, 0xc3, 0xcf, 0x9d, 0x87, 0x99, 0x9a, + 0x6d, 0xd7, 0x4c, 0x3c, 0x4b, 0x21, 0x5b, 0x8d, 0xed, 0xd9, 0x2a, 0xf6, 0x74, 0xd7, 0x70, 0x7c, + 0xdb, 0xe5, 0xc6, 0x1b, 0x63, 0x18, 0x45, 0x81, 0x21, 0xaf, 0xc0, 0xf8, 0x05, 0xc3, 0xc4, 0x0b, + 0x01, 0xe2, 0x06, 0xf6, 0xd1, 0x39, 0x48, 0x6d, 0x1b, 0x26, 0xce, 0x4b, 0x33, 0xc9, 0x13, 0x43, + 0xa7, 0xee, 0x2b, 0x36, 0x11, 0x15, 0xe3, 0x14, 0xeb, 0x04, 0xac, 0x50, 0x0a, 0xf9, 0x3b, 0x29, + 0x98, 0x68, 0xf3, 0x15, 0x21, 0x48, 0x59, 0x5a, 0x1d, 0x53, 0xab, 0x64, 0x15, 0xfa, 0x8c, 0xf2, + 0x30, 0xe8, 0x68, 0xfa, 0x35, 0xad, 0x86, 0xa9, 0x51, 0xb2, 0x8a, 0x78, 0x45, 0x53, 0x00, 0x55, + 0xec, 0x60, 0xab, 0x8a, 0x2d, 0x7d, 0x2f, 0x9f, 0x9c, 0x49, 0x9e, 0xc8, 0x2a, 0x11, 0x08, 0x7a, + 0x08, 0xc6, 0x9d, 0xc6, 0x96, 0x69, 0xe8, 0x6a, 0x04, 0x0d, 0x66, 0x92, 0x27, 0xd2, 0x4a, 0x8e, + 0x7d, 0x58, 0x08, 0x91, 0x1f, 0x80, 0xb1, 0x1b, 0x58, 0xbb, 0x16, 0x45, 0x1d, 0xa2, 0xa8, 0xa3, + 0x04, 0x1c, 0x41, 0x9c, 0x87, 0xe1, 0x3a, 0xf6, 0x3c, 0xad, 0x86, 0x55, 0x62, 0xdf, 0x7c, 0x8a, + 0x6a, 0x3f, 0xd3, 0xa2, 0x7d, 0xb3, 0xe6, 0x43, 0x9c, 0x6a, 0x73, 0xcf, 0xc1, 0x68, 0x0e, 0xb2, + 0xd8, 0x6a, 0xd4, 0x19, 0x87, 0x74, 0x07, 0xfb, 0x55, 0xac, 0x46, 0xbd, 0x99, 0x4b, 0x86, 0x90, + 0x71, 0x16, 0x83, 0x1e, 0x76, 0xaf, 0x1b, 0x3a, 0xce, 0x0f, 0x50, 0x06, 0x0f, 0xb4, 0x30, 0xd8, + 0x60, 0xdf, 0x9b, 0x79, 0x08, 0x3a, 0x34, 0x0f, 0x59, 0xbc, 0xeb, 0x63, 0xcb, 0x33, 0x6c, 0x2b, + 0x3f, 0x48, 0x99, 0xbc, 0xad, 0x4d, 0x2f, 0x62, 0xb3, 0xda, 0xcc, 0x22, 0xa4, 0x43, 0x67, 0x60, + 0xd0, 0x76, 0x48, 0xe0, 0x79, 0xf9, 0xcc, 0x8c, 0x74, 0x62, 0xe8, 0xd4, 0xf1, 0xb6, 0x8e, 0xb0, + 0xc6, 0x70, 0x14, 0x81, 0x8c, 0x96, 0x20, 0xe7, 0xd9, 0x0d, 0x57, 0xc7, 0xaa, 0x6e, 0x57, 0xb1, + 0x6a, 0x58, 0xdb, 0x76, 0x3e, 0x4b, 0x19, 0x4c, 0xb7, 0x2a, 0x42, 0x11, 0xe7, 0xed, 0x2a, 0x5e, + 0xb2, 0xb6, 0x6d, 0x65, 0xd4, 0x8b, 0xbd, 0x93, 0x78, 0xf5, 0xf6, 0x2c, 0x5f, 0xdb, 0xcd, 0x0f, + 0x53, 0x0f, 0xe1, 0x6f, 0xf2, 0xaf, 0x0d, 0xc0, 0x58, 0x2f, 0x2e, 0x76, 0x1e, 0xd2, 0xdb, 0x44, + 0xcb, 0x7c, 0xa2, 0x1f, 0x1b, 0x30, 0x9a, 0xb8, 0x11, 0x07, 0x0e, 0x68, 0xc4, 0x39, 0x18, 0xb2, + 0xb0, 0xe7, 0xe3, 0x2a, 0xf3, 0x88, 0x64, 0x8f, 0x3e, 0x05, 0x8c, 0xa8, 0xd5, 0xa5, 0x52, 0x07, + 0x72, 0xa9, 0x67, 0x61, 0x2c, 0x10, 0x49, 0x75, 0x35, 0xab, 0x26, 0x7c, 0x73, 0xb6, 0x9b, 0x24, + 0xc5, 0x8a, 0xa0, 0x53, 0x08, 0x99, 0x32, 0x8a, 0x63, 0xef, 0x68, 0x01, 0xc0, 0xb6, 0xb0, 0xbd, + 0xad, 0x56, 0xb1, 0x6e, 0xe6, 0x33, 0x1d, 0xac, 0xb4, 0x46, 0x50, 0x5a, 0xac, 0x64, 0x33, 0xa8, + 0x6e, 0xa2, 0x27, 0x43, 0x57, 0x1b, 0xec, 0xe0, 0x29, 0x2b, 0x2c, 0xc8, 0x5a, 0xbc, 0xed, 0x0a, + 0x8c, 0xba, 0x98, 0xf8, 0x3d, 0xae, 0x72, 0xcd, 0xb2, 0x54, 0x88, 0x62, 0x57, 0xcd, 0x14, 0x4e, + 0xc6, 0x14, 0x1b, 0x71, 0xa3, 0xaf, 0xe8, 0x5e, 0x08, 0x00, 0x2a, 0x75, 0x2b, 0xa0, 0x59, 0x68, + 0x58, 0x00, 0x57, 0xb5, 0x3a, 0x2e, 0xdc, 0x84, 0xd1, 0xb8, 0x79, 0x48, 0x9a, 0xf7, 0x7c, 0xcd, + 0xf5, 0xa9, 0x17, 0xa6, 0x15, 0xf6, 0x42, 0x06, 0x22, 0x6c, 0x55, 0x69, 0x96, 0x4b, 0x2b, 0xe4, + 0x11, 0xbd, 0x2b, 0x54, 0x38, 0x49, 0x15, 0xbe, 0xbf, 0xb5, 0x47, 0x63, 0x9c, 0x9b, 0xf5, 0x2e, + 0x9c, 0x85, 0x91, 0x98, 0x02, 0xbd, 0x36, 0x2d, 0xbf, 0x1f, 0x0e, 0xb7, 0x65, 0x8d, 0x9e, 0x85, + 0xc9, 0x86, 0x65, 0x58, 0x3e, 0x76, 0x1d, 0x17, 0x13, 0x8f, 0x65, 0x4d, 0xe5, 0xff, 0xcb, 0x60, + 0x07, 0x9f, 0xbb, 0x12, 0xc5, 0x66, 0x5c, 0x94, 0x89, 0x46, 0x2b, 0xf0, 0x64, 0x36, 0xf3, 0xdd, + 0xc1, 0xdc, 0x0b, 0x2f, 0xbc, 0xf0, 0x42, 0x42, 0xfe, 0xc4, 0x00, 0x4c, 0xb6, 0x8b, 0x99, 0xb6, + 0xe1, 0x7b, 0x04, 0x06, 0xac, 0x46, 0x7d, 0x0b, 0xbb, 0xd4, 0x48, 0x69, 0x85, 0xbf, 0xa1, 0x39, + 0x48, 0x9b, 0xda, 0x16, 0x66, 0x43, 0xf2, 0xe8, 0xa9, 0x87, 0x7a, 0x8a, 0xca, 0xe2, 0x32, 0x21, + 0x51, 0x18, 0x25, 0x7a, 0x27, 0xa4, 0x78, 0x8a, 0x26, 0x1c, 0x4e, 0xf6, 0xc6, 0x81, 0xc4, 0x92, + 0x42, 0xe9, 0xd0, 0x31, 0xc8, 0x92, 0xbf, 0xcc, 0x37, 0x06, 0xa8, 0xcc, 0x19, 0x02, 0x20, 0x7e, + 0x81, 0x0a, 0x90, 0xa1, 0x61, 0x52, 0xc5, 0x62, 0x68, 0x0b, 0xde, 0x89, 0x63, 0x55, 0xf1, 0xb6, + 0xd6, 0x30, 0x7d, 0xf5, 0xba, 0x66, 0x36, 0x30, 0x75, 0xf8, 0xac, 0x32, 0xcc, 0x81, 0x57, 0x09, + 0x8c, 0x54, 0x1e, 0x2c, 0xaa, 0x0c, 0xab, 0x8a, 0x77, 0x69, 0xf6, 0x4c, 0x2b, 0x2c, 0xd0, 0x96, + 0x08, 0x84, 0x34, 0xff, 0x9c, 0x67, 0x5b, 0xc2, 0x35, 0x69, 0x13, 0x04, 0x40, 0x9b, 0x3f, 0xdb, + 0x9c, 0xb8, 0xef, 0x6e, 0xaf, 0x5e, 0xb3, 0x4f, 0xc9, 0xbf, 0x9a, 0x80, 0x14, 0xcd, 0x17, 0x63, + 0x30, 0xb4, 0xf9, 0xee, 0xf5, 0x8a, 0xba, 0xb0, 0x76, 0xa5, 0xbc, 0x5c, 0xc9, 0x49, 0x68, 0x14, + 0x80, 0x02, 0x2e, 0x2c, 0xaf, 0xcd, 0x6d, 0xe6, 0x12, 0xc1, 0xfb, 0xd2, 0xea, 0xe6, 0x99, 0xd3, + 0xb9, 0x64, 0x40, 0x70, 0x85, 0x01, 0x52, 0x51, 0x84, 0xc7, 0x4f, 0xe5, 0xd2, 0x28, 0x07, 0xc3, + 0x8c, 0xc1, 0xd2, 0xb3, 0x95, 0x85, 0x33, 0xa7, 0x73, 0x03, 0x71, 0xc8, 0xe3, 0xa7, 0x72, 0x83, + 0x68, 0x04, 0xb2, 0x14, 0x52, 0x5e, 0x5b, 0x5b, 0xce, 0x65, 0x02, 0x9e, 0x1b, 0x9b, 0xca, 0xd2, + 0xea, 0x62, 0x2e, 0x1b, 0xf0, 0x5c, 0x54, 0xd6, 0xae, 0xac, 0xe7, 0x20, 0xe0, 0xb0, 0x52, 0xd9, + 0xd8, 0x98, 0x5b, 0xac, 0xe4, 0x86, 0x02, 0x8c, 0xf2, 0xbb, 0x37, 0x2b, 0x1b, 0xb9, 0xe1, 0x98, + 0x58, 0x8f, 0x9f, 0xca, 0x8d, 0x04, 0x4d, 0x54, 0x56, 0xaf, 0xac, 0xe4, 0x46, 0xd1, 0x38, 0x8c, + 0xb0, 0x26, 0x84, 0x10, 0x63, 0x4d, 0xa0, 0x33, 0xa7, 0x73, 0xb9, 0x50, 0x10, 0xc6, 0x65, 0x3c, + 0x06, 0x38, 0x73, 0x3a, 0x87, 0xe4, 0x79, 0x48, 0x53, 0xef, 0x42, 0x08, 0x46, 0x97, 0xe7, 0xca, + 0x95, 0x65, 0x75, 0x6d, 0x7d, 0x73, 0x69, 0x6d, 0x75, 0x6e, 0x39, 0x27, 0x85, 0x30, 0xa5, 0xf2, + 0xf4, 0x95, 0x25, 0xa5, 0xb2, 0x90, 0x4b, 0x44, 0x61, 0xeb, 0x95, 0xb9, 0xcd, 0xca, 0x42, 0x2e, + 0x29, 0xeb, 0x30, 0xd9, 0x2e, 0x4f, 0xb6, 0x8d, 0x8c, 0x48, 0x17, 0x27, 0x3a, 0x74, 0x31, 0xe5, + 0xd5, 0xd2, 0xc5, 0xdf, 0x4e, 0xc0, 0x44, 0x9b, 0xb1, 0xa2, 0x6d, 0x23, 0x4f, 0x41, 0x9a, 0xb9, + 0x28, 0x1b, 0x3d, 0x1f, 0x6c, 0x3b, 0xe8, 0x50, 0x87, 0x6d, 0x19, 0x41, 0x29, 0x5d, 0xb4, 0x82, + 0x48, 0x76, 0xa8, 0x20, 0x08, 0x8b, 0x96, 0x9c, 0xfe, 0xa3, 0x2d, 0x39, 0x9d, 0x0d, 0x7b, 0x67, + 0x7a, 0x19, 0xf6, 0x28, 0xac, 0xbf, 0xdc, 0x9e, 0x6e, 0x93, 0xdb, 0xcf, 0xc3, 0x78, 0x0b, 0xa3, + 0x9e, 0x73, 0xec, 0x07, 0x25, 0xc8, 0x77, 0x32, 0x4e, 0x97, 0x4c, 0x97, 0x88, 0x65, 0xba, 0xf3, + 0xcd, 0x16, 0xbc, 0xa7, 0x73, 0x27, 0xb4, 0xf4, 0xf5, 0x17, 0x25, 0x38, 0xd2, 0xbe, 0x52, 0x6c, + 0x2b, 0xc3, 0x3b, 0x61, 0xa0, 0x8e, 0xfd, 0x1d, 0x5b, 0x54, 0x4b, 0xf7, 0xb7, 0x19, 0x83, 0xc9, + 0xe7, 0xe6, 0xce, 0xe6, 0x54, 0xd1, 0x41, 0x3c, 0xd9, 0xa9, 0xdc, 0x63, 0xd2, 0xb4, 0x48, 0xfa, + 0xd1, 0x04, 0x1c, 0x6e, 0xcb, 0xbc, 0xad, 0xa0, 0x77, 0x03, 0x18, 0x96, 0xd3, 0xf0, 0x59, 0x45, + 0xc4, 0x12, 0x6c, 0x96, 0x42, 0x68, 0xf2, 0x22, 0xc9, 0xb3, 0xe1, 0x07, 0xdf, 0x93, 0xf4, 0x3b, + 0x30, 0x10, 0x45, 0x38, 0x17, 0x0a, 0x9a, 0xa2, 0x82, 0x4e, 0x75, 0xd0, 0xb4, 0xc5, 0x31, 0x1f, + 0x85, 0x9c, 0x6e, 0x1a, 0xd8, 0xf2, 0x55, 0xcf, 0x77, 0xb1, 0x56, 0x37, 0xac, 0x1a, 0x1d, 0x41, + 0x32, 0xa5, 0xf4, 0xb6, 0x66, 0x7a, 0x58, 0x19, 0x63, 0x9f, 0x37, 0xc4, 0x57, 0x42, 0x41, 0x1d, + 0xc8, 0x8d, 0x50, 0x0c, 0xc4, 0x28, 0xd8, 0xe7, 0x80, 0x42, 0xfe, 0xe9, 0x2c, 0x0c, 0x45, 0xea, + 0x6a, 0x74, 0x0f, 0x0c, 0x3f, 0xa7, 0x5d, 0xd7, 0x54, 0x31, 0x57, 0x62, 0x96, 0x18, 0x22, 0xb0, + 0x75, 0x3e, 0x5f, 0x7a, 0x14, 0x26, 0x29, 0x8a, 0xdd, 0xf0, 0xb1, 0xab, 0xea, 0xa6, 0xe6, 0x79, + 0xd4, 0x68, 0x19, 0x8a, 0x8a, 0xc8, 0xb7, 0x35, 0xf2, 0x69, 0x5e, 0x7c, 0x41, 0x4f, 0xc0, 0x04, + 0xa5, 0xa8, 0x37, 0x4c, 0xdf, 0x70, 0x4c, 0xac, 0x92, 0xd9, 0x9b, 0x47, 0x47, 0x92, 0x40, 0xb2, + 0x71, 0x82, 0xb1, 0xc2, 0x11, 0x88, 0x44, 0x1e, 0x5a, 0x80, 0xbb, 0x29, 0x59, 0x0d, 0x5b, 0xd8, + 0xd5, 0x7c, 0xac, 0xe2, 0xe7, 0x1b, 0x9a, 0xe9, 0xa9, 0x9a, 0x55, 0x55, 0x77, 0x34, 0x6f, 0x27, + 0x3f, 0x49, 0x18, 0x94, 0x13, 0x79, 0x49, 0x39, 0x4a, 0x10, 0x17, 0x39, 0x5e, 0x85, 0xa2, 0xcd, + 0x59, 0xd5, 0x8b, 0x9a, 0xb7, 0x83, 0x4a, 0x70, 0x84, 0x72, 0xf1, 0x7c, 0xd7, 0xb0, 0x6a, 0xaa, + 0xbe, 0x83, 0xf5, 0x6b, 0x6a, 0xc3, 0xdf, 0x3e, 0x97, 0x3f, 0x16, 0x6d, 0x9f, 0x4a, 0xb8, 0x41, + 0x71, 0xe6, 0x09, 0xca, 0x15, 0x7f, 0xfb, 0x1c, 0xda, 0x80, 0x61, 0xd2, 0x19, 0x75, 0xe3, 0x26, + 0x56, 0xb7, 0x6d, 0x97, 0x0e, 0x8d, 0xa3, 0x6d, 0x52, 0x53, 0xc4, 0x82, 0xc5, 0x35, 0x4e, 0xb0, + 0x62, 0x57, 0x71, 0x29, 0xbd, 0xb1, 0x5e, 0xa9, 0x2c, 0x28, 0x43, 0x82, 0xcb, 0x05, 0xdb, 0x25, + 0x0e, 0x55, 0xb3, 0x03, 0x03, 0x0f, 0x31, 0x87, 0xaa, 0xd9, 0xc2, 0xbc, 0x4f, 0xc0, 0x84, 0xae, + 0x33, 0x9d, 0x0d, 0x5d, 0xe5, 0x73, 0x2c, 0x2f, 0x9f, 0x8b, 0x19, 0x4b, 0xd7, 0x17, 0x19, 0x02, + 0xf7, 0x71, 0x0f, 0x3d, 0x09, 0x87, 0x43, 0x63, 0x45, 0x09, 0xc7, 0x5b, 0xb4, 0x6c, 0x26, 0x7d, + 0x02, 0x26, 0x9c, 0xbd, 0x56, 0x42, 0x14, 0x6b, 0xd1, 0xd9, 0x6b, 0x26, 0x3b, 0x0b, 0x93, 0xce, + 0x8e, 0xd3, 0x4a, 0x77, 0x32, 0x4a, 0x87, 0x9c, 0x1d, 0xa7, 0x99, 0xf0, 0x6d, 0x74, 0xc2, 0xed, + 0x62, 0x5d, 0xf3, 0x71, 0x35, 0x7f, 0x57, 0x14, 0x3d, 0xf2, 0x01, 0xcd, 0x42, 0x4e, 0xd7, 0x55, + 0x6c, 0x69, 0x5b, 0x26, 0x56, 0x35, 0x17, 0x5b, 0x9a, 0x97, 0x9f, 0x8e, 0x22, 0x8f, 0xea, 0x7a, + 0x85, 0x7e, 0x9d, 0xa3, 0x1f, 0xd1, 0x49, 0x18, 0xb7, 0xb7, 0x9e, 0xd3, 0x99, 0x4b, 0xaa, 0x8e, + 0x8b, 0xb7, 0x8d, 0xdd, 0xfc, 0x7d, 0xd4, 0xbe, 0x63, 0xe4, 0x03, 0x75, 0xc8, 0x75, 0x0a, 0x46, + 0x0f, 0x42, 0x4e, 0xf7, 0x76, 0x34, 0xd7, 0xa1, 0x39, 0xd9, 0x73, 0x34, 0x1d, 0xe7, 0xdf, 0xc6, + 0x50, 0x19, 0x7c, 0x55, 0x80, 0x49, 0x48, 0x78, 0x37, 0x8c, 0x6d, 0x5f, 0x70, 0x7c, 0x80, 0x85, + 0x04, 0x85, 0x71, 0x6e, 0x27, 0x20, 0x47, 0x4c, 0x11, 0x6b, 0xf8, 0x04, 0x45, 0x1b, 0x75, 0x76, + 0x9c, 0x68, 0xbb, 0xf7, 0xc2, 0x08, 0xc1, 0x0c, 0x1b, 0x7d, 0x90, 0x15, 0x64, 0xce, 0x4e, 0xa4, + 0xc5, 0xd3, 0x70, 0x84, 0x20, 0xd5, 0xb1, 0xaf, 0x55, 0x35, 0x5f, 0x8b, 0x60, 0x3f, 0x4c, 0xb1, + 0x89, 0xdd, 0x57, 0xf8, 0xc7, 0x98, 0x9c, 0x6e, 0x63, 0x6b, 0x2f, 0xf0, 0xac, 0x47, 0x98, 0x9c, + 0x04, 0x26, 0x7c, 0xeb, 0x75, 0x2b, 0xba, 0xe5, 0x12, 0x0c, 0x47, 0x1d, 0x1f, 0x65, 0x81, 0xb9, + 0x7e, 0x4e, 0x22, 0x55, 0xd0, 0xfc, 0xda, 0x02, 0xa9, 0x5f, 0xde, 0x53, 0xc9, 0x25, 0x48, 0x1d, + 0xb5, 0xbc, 0xb4, 0x59, 0x51, 0x95, 0x2b, 0xab, 0x9b, 0x4b, 0x2b, 0x95, 0x5c, 0x32, 0x52, 0xb0, + 0x5f, 0x4a, 0x65, 0xee, 0xcf, 0x3d, 0x20, 0x7f, 0x23, 0x01, 0xa3, 0xf1, 0x19, 0x18, 0x7a, 0x3b, + 0xdc, 0x25, 0x96, 0x4b, 0x3c, 0xec, 0xab, 0x37, 0x0c, 0x97, 0x46, 0x64, 0x5d, 0x63, 0xa3, 0x63, + 0xe0, 0x13, 0x93, 0x1c, 0x6b, 0x03, 0xfb, 0xcf, 0x18, 0x2e, 0x89, 0xb7, 0xba, 0xe6, 0xa3, 0x65, + 0x98, 0xb6, 0x6c, 0xd5, 0xf3, 0x35, 0xab, 0xaa, 0xb9, 0x55, 0x35, 0x5c, 0xa8, 0x52, 0x35, 0x5d, + 0xc7, 0x9e, 0x67, 0xb3, 0x91, 0x30, 0xe0, 0x72, 0xdc, 0xb2, 0x37, 0x38, 0x72, 0x38, 0x44, 0xcc, + 0x71, 0xd4, 0x26, 0xff, 0x4d, 0x76, 0xf2, 0xdf, 0x63, 0x90, 0xad, 0x6b, 0x8e, 0x8a, 0x2d, 0xdf, + 0xdd, 0xa3, 0x75, 0x77, 0x46, 0xc9, 0xd4, 0x35, 0xa7, 0x42, 0xde, 0xdf, 0x90, 0xe9, 0xcf, 0xa5, + 0x54, 0x26, 0x93, 0xcb, 0x5e, 0x4a, 0x65, 0xb2, 0x39, 0x90, 0x5f, 0x4e, 0xc2, 0x70, 0xb4, 0x0e, + 0x27, 0xd3, 0x1a, 0x9d, 0x0e, 0x59, 0x12, 0x4d, 0x6a, 0xf7, 0xee, 0x5b, 0xb5, 0x17, 0xe7, 0xc9, + 0x58, 0x56, 0x1a, 0x60, 0xd5, 0xb1, 0xc2, 0x28, 0x49, 0x1d, 0x41, 0x9c, 0x0d, 0xb3, 0x6a, 0x24, + 0xa3, 0xf0, 0x37, 0xb4, 0x08, 0x03, 0xcf, 0x79, 0x94, 0xf7, 0x00, 0xe5, 0x7d, 0xdf, 0xfe, 0xbc, + 0x2f, 0x6d, 0x50, 0xe6, 0xd9, 0x4b, 0x1b, 0xea, 0xea, 0x9a, 0xb2, 0x32, 0xb7, 0xac, 0x70, 0x72, + 0x74, 0x14, 0x52, 0xa6, 0x76, 0x73, 0x2f, 0x3e, 0xea, 0x51, 0x50, 0xaf, 0x9d, 0x70, 0x14, 0x52, + 0x37, 0xb0, 0x76, 0x2d, 0x3e, 0xd6, 0x50, 0xd0, 0xeb, 0x18, 0x0c, 0xb3, 0x90, 0xa6, 0xf6, 0x42, + 0x00, 0xdc, 0x62, 0xb9, 0x43, 0x28, 0x03, 0xa9, 0xf9, 0x35, 0x85, 0x04, 0x44, 0x0e, 0x86, 0x19, + 0x54, 0x5d, 0x5f, 0xaa, 0xcc, 0x57, 0x72, 0x09, 0xf9, 0x09, 0x18, 0x60, 0x46, 0x20, 0xc1, 0x12, + 0x98, 0x21, 0x77, 0x88, 0xbf, 0x72, 0x1e, 0x92, 0xf8, 0x7a, 0x65, 0xa5, 0x5c, 0x51, 0x72, 0x89, + 0x78, 0x57, 0xa7, 0x72, 0x69, 0xd9, 0x83, 0xe1, 0x68, 0x21, 0xfe, 0xc6, 0x4c, 0xb2, 0xbf, 0x22, + 0xc1, 0x50, 0xa4, 0xb0, 0x26, 0x15, 0x91, 0x66, 0x9a, 0xf6, 0x0d, 0x55, 0x33, 0x0d, 0xcd, 0xe3, + 0xae, 0x01, 0x14, 0x34, 0x47, 0x20, 0xbd, 0x76, 0xdd, 0x1b, 0x14, 0x22, 0xe9, 0xdc, 0x80, 0xfc, + 0x19, 0x09, 0x72, 0xcd, 0x95, 0x6d, 0x93, 0x98, 0xd2, 0x0f, 0x52, 0x4c, 0xf9, 0xd3, 0x12, 0x8c, + 0xc6, 0xcb, 0xd9, 0x26, 0xf1, 0xee, 0xf9, 0x81, 0x8a, 0xf7, 0x07, 0x09, 0x18, 0x89, 0x15, 0xb1, + 0xbd, 0x4a, 0xf7, 0x3c, 0x8c, 0x1b, 0x55, 0x5c, 0x77, 0x6c, 0x1f, 0x5b, 0xfa, 0x9e, 0x6a, 0xe2, + 0xeb, 0xd8, 0xcc, 0xcb, 0x34, 0x69, 0xcc, 0xee, 0x5f, 0x26, 0x17, 0x97, 0x42, 0xba, 0x65, 0x42, + 0x56, 0x9a, 0x58, 0x5a, 0xa8, 0xac, 0xac, 0xaf, 0x6d, 0x56, 0x56, 0xe7, 0xdf, 0xad, 0x5e, 0x59, + 0xbd, 0xbc, 0xba, 0xf6, 0xcc, 0xaa, 0x92, 0x33, 0x9a, 0xd0, 0x5e, 0xc7, 0xb0, 0x5f, 0x87, 0x5c, + 0xb3, 0x50, 0xe8, 0x2e, 0x68, 0x27, 0x56, 0xee, 0x10, 0x9a, 0x80, 0xb1, 0xd5, 0x35, 0x75, 0x63, + 0x69, 0xa1, 0xa2, 0x56, 0x2e, 0x5c, 0xa8, 0xcc, 0x6f, 0x6e, 0xb0, 0x85, 0x8f, 0x00, 0x7b, 0x33, + 0x16, 0xe0, 0xf2, 0xa7, 0x92, 0x30, 0xd1, 0x46, 0x12, 0x34, 0xc7, 0xa7, 0x2c, 0x6c, 0x16, 0xf5, + 0x48, 0x2f, 0xd2, 0x17, 0x49, 0xcd, 0xb0, 0xae, 0xb9, 0x3e, 0x9f, 0xe1, 0x3c, 0x08, 0xc4, 0x4a, + 0x96, 0x6f, 0x6c, 0x1b, 0xd8, 0xe5, 0xeb, 0x44, 0x6c, 0x1e, 0x33, 0x16, 0xc2, 0xd9, 0x52, 0xd1, + 0xc3, 0x80, 0x1c, 0xdb, 0x33, 0x7c, 0xe3, 0x3a, 0x56, 0x0d, 0x4b, 0x2c, 0x2a, 0xa5, 0xe8, 0x2e, + 0x53, 0x4e, 0x7c, 0x59, 0xb2, 0xfc, 0x00, 0xdb, 0xc2, 0x35, 0xad, 0x09, 0x9b, 0x24, 0xf3, 0xa4, + 0x92, 0x13, 0x5f, 0x02, 0xec, 0x7b, 0x60, 0xb8, 0x6a, 0x37, 0x48, 0xb1, 0xc7, 0xf0, 0xc8, 0xd8, + 0x21, 0x29, 0x43, 0x0c, 0x16, 0xa0, 0xf0, 0x32, 0x3e, 0x5c, 0xcd, 0x1a, 0x56, 0x86, 0x18, 0x8c, + 0xa1, 0x3c, 0x00, 0x63, 0x5a, 0xad, 0xe6, 0x12, 0xe6, 0x82, 0x11, 0x9b, 0x98, 0x8c, 0x06, 0x60, + 0x8a, 0x58, 0xb8, 0x04, 0x19, 0x61, 0x07, 0x32, 0x54, 0x13, 0x4b, 0xa8, 0x0e, 0x9b, 0x6d, 0x27, + 0x4e, 0x64, 0x95, 0x8c, 0x25, 0x3e, 0xde, 0x03, 0xc3, 0x86, 0xa7, 0x86, 0x8b, 0xf3, 0x89, 0x99, + 0xc4, 0x89, 0x8c, 0x32, 0x64, 0x78, 0xc1, 0xc2, 0xa6, 0xfc, 0xc5, 0x04, 0x8c, 0xc6, 0x37, 0x17, + 0xd0, 0x02, 0x64, 0x4c, 0x5b, 0xa7, 0x5b, 0x89, 0x7c, 0x67, 0xeb, 0x44, 0x97, 0xfd, 0x88, 0xe2, + 0x32, 0xc7, 0x57, 0x02, 0xca, 0xc2, 0xbf, 0x92, 0x20, 0x23, 0xc0, 0xe8, 0x08, 0xa4, 0x1c, 0xcd, + 0xdf, 0xa1, 0xec, 0xd2, 0xe5, 0x44, 0x4e, 0x52, 0xe8, 0x3b, 0x81, 0x7b, 0x8e, 0x66, 0x51, 0x17, + 0xe0, 0x70, 0xf2, 0x4e, 0xfa, 0xd5, 0xc4, 0x5a, 0x95, 0xce, 0x7a, 0xec, 0x7a, 0x1d, 0x5b, 0xbe, + 0x27, 0xfa, 0x95, 0xc3, 0xe7, 0x39, 0x18, 0x3d, 0x04, 0xe3, 0xbe, 0xab, 0x19, 0x66, 0x0c, 0x37, + 0x45, 0x71, 0x73, 0xe2, 0x43, 0x80, 0x5c, 0x82, 0xa3, 0x82, 0x6f, 0x15, 0xfb, 0x9a, 0xbe, 0x83, + 0xab, 0x21, 0xd1, 0x00, 0x5d, 0xdd, 0xb8, 0x8b, 0x23, 0x2c, 0xf0, 0xef, 0x82, 0x56, 0xfe, 0x86, + 0x04, 0xe3, 0x62, 0x9e, 0x56, 0x0d, 0x8c, 0xb5, 0x02, 0xa0, 0x59, 0x96, 0xed, 0x47, 0xcd, 0xd5, + 0xea, 0xca, 0x2d, 0x74, 0xc5, 0xb9, 0x80, 0x48, 0x89, 0x30, 0x28, 0xd4, 0x01, 0xc2, 0x2f, 0x1d, + 0xcd, 0x36, 0x0d, 0x43, 0x7c, 0xe7, 0x88, 0x6e, 0x3f, 0xb2, 0x99, 0x3d, 0x30, 0x10, 0x99, 0xd0, + 0xa1, 0x49, 0x48, 0x6f, 0xe1, 0x9a, 0x61, 0xf1, 0xf5, 0x60, 0xf6, 0x22, 0xd6, 0x5f, 0x52, 0xc1, + 0xfa, 0x4b, 0xf9, 0x63, 0x12, 0x4c, 0xe8, 0x76, 0xbd, 0x59, 0xde, 0x72, 0xae, 0x69, 0x79, 0xc1, + 0xbb, 0x28, 0xbd, 0xe7, 0x9d, 0x91, 0x9d, 0xd6, 0x9a, 0x6d, 0x6a, 0x56, 0x2d, 0xdc, 0x3f, 0xa5, + 0x0f, 0xfa, 0x23, 0x35, 0x6c, 0x3d, 0x52, 0xb3, 0x23, 0xbb, 0xa9, 0xe7, 0xc3, 0xc7, 0xff, 0x2b, + 0x49, 0x9f, 0x4f, 0x24, 0x17, 0xd7, 0xcb, 0x5f, 0x4a, 0x14, 0x16, 0x59, 0x73, 0xeb, 0xc2, 0x3c, + 0x0a, 0xde, 0x36, 0xb1, 0x4e, 0x54, 0x86, 0xef, 0x3d, 0x04, 0x93, 0x35, 0xbb, 0x66, 0x53, 0x8e, + 0xb3, 0xe4, 0x89, 0xef, 0xc8, 0x66, 0x03, 0x68, 0xa1, 0xeb, 0xf6, 0x6d, 0x69, 0x15, 0x26, 0x38, + 0xb2, 0x4a, 0xb7, 0x84, 0xd8, 0xc4, 0x06, 0xed, 0xbb, 0xac, 0x96, 0xff, 0xe5, 0xef, 0xd0, 0x01, + 0x5d, 0x19, 0xe7, 0xa4, 0xe4, 0x1b, 0x9b, 0xfb, 0x94, 0x14, 0x38, 0x1c, 0xe3, 0xc7, 0xc2, 0x16, + 0xbb, 0x5d, 0x38, 0xfe, 0x26, 0xe7, 0x38, 0x11, 0xe1, 0xb8, 0xc1, 0x49, 0x4b, 0xf3, 0x30, 0xd2, + 0x0f, 0xaf, 0xdf, 0xe2, 0xbc, 0x86, 0x71, 0x94, 0xc9, 0x22, 0x8c, 0x51, 0x26, 0x7a, 0xc3, 0xf3, + 0xed, 0x3a, 0xcd, 0x89, 0xfb, 0xb3, 0xf9, 0xed, 0xef, 0xb0, 0x38, 0x1a, 0x25, 0x64, 0xf3, 0x01, + 0x55, 0xa9, 0x04, 0x74, 0x17, 0xac, 0x8a, 0x75, 0xb3, 0x0b, 0x87, 0xaf, 0x71, 0x41, 0x02, 0xfc, + 0xd2, 0x55, 0x98, 0x24, 0xcf, 0x34, 0x65, 0x45, 0x25, 0xe9, 0xbe, 0x06, 0x97, 0xff, 0xc6, 0x07, + 0x59, 0xa8, 0x4e, 0x04, 0x0c, 0x22, 0x32, 0x45, 0x7a, 0xb1, 0x86, 0x7d, 0x1f, 0xbb, 0x9e, 0xaa, + 0x99, 0xed, 0xc4, 0x8b, 0x2c, 0x62, 0xe4, 0x3f, 0xf9, 0xfd, 0x78, 0x2f, 0x2e, 0x32, 0xca, 0x39, + 0xd3, 0x2c, 0x5d, 0x81, 0xbb, 0xda, 0x78, 0x45, 0x0f, 0x3c, 0x3f, 0xc5, 0x79, 0x4e, 0xb6, 0x78, + 0x06, 0x61, 0xbb, 0x0e, 0x02, 0x1e, 0xf4, 0x65, 0x0f, 0x3c, 0x7f, 0x8e, 0xf3, 0x44, 0x9c, 0x56, + 0x74, 0x29, 0xe1, 0x78, 0x09, 0xc6, 0xaf, 0x63, 0x77, 0xcb, 0xf6, 0xf8, 0xc2, 0x51, 0x0f, 0xec, + 0x3e, 0xcd, 0xd9, 0x8d, 0x71, 0x42, 0xba, 0x92, 0x44, 0x78, 0x3d, 0x09, 0x99, 0x6d, 0x4d, 0xc7, + 0x3d, 0xb0, 0x78, 0x89, 0xb3, 0x18, 0x24, 0xf8, 0x84, 0x74, 0x0e, 0x86, 0x6b, 0x36, 0x1f, 0xb5, + 0xba, 0x93, 0x7f, 0x86, 0x93, 0x0f, 0x09, 0x1a, 0xce, 0xc2, 0xb1, 0x9d, 0x86, 0x49, 0x86, 0xb4, + 0xee, 0x2c, 0xfe, 0xaa, 0x60, 0x21, 0x68, 0x38, 0x8b, 0x3e, 0xcc, 0xfa, 0x59, 0xc1, 0xc2, 0x8b, + 0xd8, 0xf3, 0x29, 0x18, 0xb2, 0x2d, 0x73, 0xcf, 0xb6, 0x7a, 0x11, 0xe2, 0x73, 0x9c, 0x03, 0x70, + 0x12, 0xc2, 0xe0, 0x3c, 0x64, 0x7b, 0xed, 0x88, 0xbf, 0xfe, 0x7d, 0x11, 0x1e, 0xa2, 0x07, 0x16, + 0x61, 0x4c, 0x24, 0x28, 0xc3, 0xb6, 0x7a, 0x60, 0xf1, 0x37, 0x38, 0x8b, 0xd1, 0x08, 0x19, 0x57, + 0xc3, 0xc7, 0x9e, 0x5f, 0xc3, 0xbd, 0x30, 0xf9, 0xa2, 0x50, 0x83, 0x93, 0x70, 0x53, 0x6e, 0x61, + 0x4b, 0xdf, 0xe9, 0x8d, 0xc3, 0xcf, 0x0b, 0x53, 0x0a, 0x1a, 0xc2, 0x62, 0x1e, 0x46, 0xea, 0x9a, + 0xeb, 0xed, 0x68, 0x66, 0x4f, 0xdd, 0xf1, 0x37, 0x39, 0x8f, 0xe1, 0x80, 0x88, 0x5b, 0xa4, 0x61, + 0xf5, 0xc3, 0xe6, 0x4b, 0xc2, 0x22, 0x11, 0x32, 0x1e, 0x7a, 0x9e, 0x4f, 0x57, 0xd9, 0xfa, 0xe1, + 0xf6, 0x0b, 0x22, 0xf4, 0x18, 0xed, 0x4a, 0x94, 0xe3, 0x79, 0xc8, 0x7a, 0xc6, 0xcd, 0x9e, 0xd8, + 0xfc, 0x2d, 0xd1, 0xd3, 0x94, 0x80, 0x10, 0xbf, 0x1b, 0x8e, 0xb6, 0x1d, 0x26, 0x7a, 0x60, 0xf6, + 0xb7, 0x39, 0xb3, 0x23, 0x6d, 0x86, 0x0a, 0x9e, 0x12, 0xfa, 0x65, 0xf9, 0x77, 0x44, 0x4a, 0xc0, + 0x4d, 0xbc, 0xd6, 0xc9, 0x3c, 0xc2, 0xd3, 0xb6, 0xfb, 0xb3, 0xda, 0x2f, 0x0a, 0xab, 0x31, 0xda, + 0x98, 0xd5, 0x36, 0xe1, 0x08, 0xe7, 0xd8, 0x5f, 0xbf, 0xfe, 0x92, 0x48, 0xac, 0x8c, 0xfa, 0x4a, + 0xbc, 0x77, 0xdf, 0x0b, 0x85, 0xc0, 0x9c, 0xa2, 0x60, 0xf5, 0xd4, 0xba, 0xe6, 0xf4, 0xc0, 0xf9, + 0x97, 0x39, 0x67, 0x91, 0xf1, 0x83, 0x8a, 0xd7, 0x5b, 0xd1, 0x1c, 0xc2, 0xfc, 0x59, 0xc8, 0x0b, + 0xe6, 0x0d, 0xcb, 0xc5, 0xba, 0x5d, 0xb3, 0x8c, 0x9b, 0xb8, 0xda, 0x03, 0xeb, 0xbf, 0xdb, 0xd4, + 0x55, 0x57, 0x22, 0xe4, 0x84, 0xf3, 0x12, 0xe4, 0x82, 0x5a, 0x45, 0x35, 0xea, 0x8e, 0xed, 0xfa, + 0x5d, 0x38, 0x7e, 0x59, 0xf4, 0x54, 0x40, 0xb7, 0x44, 0xc9, 0x4a, 0x15, 0x18, 0xa5, 0xaf, 0xbd, + 0xba, 0xe4, 0xaf, 0x70, 0x46, 0x23, 0x21, 0x15, 0x4f, 0x1c, 0xba, 0x5d, 0x77, 0x34, 0xb7, 0x97, + 0xfc, 0xf7, 0xf7, 0x44, 0xe2, 0xe0, 0x24, 0x3c, 0x71, 0xf8, 0x7b, 0x0e, 0x26, 0xa3, 0x7d, 0x0f, + 0x1c, 0x7e, 0x55, 0x24, 0x0e, 0x41, 0xc3, 0x59, 0x88, 0x82, 0xa1, 0x07, 0x16, 0x7f, 0x5f, 0xb0, + 0x10, 0x34, 0x84, 0xc5, 0xd3, 0xe1, 0x40, 0xeb, 0xe2, 0x9a, 0xe1, 0xf9, 0x2e, 0x2b, 0x93, 0xf7, + 0x67, 0xf5, 0x0f, 0xbe, 0x1f, 0x2f, 0xc2, 0x94, 0x08, 0x29, 0xc9, 0x44, 0x7c, 0xd9, 0x95, 0xce, + 0xa2, 0xba, 0x0b, 0xf6, 0x6b, 0x22, 0x13, 0x45, 0xc8, 0x88, 0x6c, 0x91, 0x0a, 0x91, 0x98, 0x5d, + 0x27, 0x73, 0x87, 0x1e, 0xd8, 0xfd, 0xc3, 0x26, 0xe1, 0x36, 0x04, 0x2d, 0xe1, 0x19, 0xa9, 0x7f, + 0x1a, 0xd6, 0x35, 0xbc, 0xd7, 0x93, 0x77, 0xfe, 0x7a, 0x53, 0xfd, 0x73, 0x85, 0x51, 0xb2, 0x1c, + 0x32, 0xd6, 0x54, 0x4f, 0xa1, 0x6e, 0xe7, 0x87, 0xf2, 0x3f, 0xf6, 0x0a, 0xd7, 0x37, 0x5e, 0x4e, + 0x95, 0x96, 0x89, 0x93, 0xc7, 0x8b, 0x9e, 0xee, 0xcc, 0x3e, 0xf8, 0x4a, 0xe0, 0xe7, 0xb1, 0x9a, + 0xa7, 0x74, 0x01, 0x46, 0x62, 0x05, 0x4f, 0x77, 0x56, 0x1f, 0xe2, 0xac, 0x86, 0xa3, 0xf5, 0x4e, + 0xe9, 0x09, 0x48, 0x91, 0xe2, 0xa5, 0x3b, 0xf9, 0x87, 0x39, 0x39, 0x45, 0x2f, 0xbd, 0x03, 0x32, + 0xa2, 0x68, 0xe9, 0x4e, 0xfa, 0x11, 0x4e, 0x1a, 0x90, 0x10, 0x72, 0x51, 0xb0, 0x74, 0x27, 0xff, + 0xf3, 0x82, 0x5c, 0x90, 0x10, 0xf2, 0xde, 0x4d, 0xf8, 0x95, 0xbf, 0x90, 0xe2, 0x83, 0x8e, 0xb0, + 0xdd, 0x79, 0x18, 0xe4, 0x95, 0x4a, 0x77, 0xea, 0x8f, 0xf2, 0xc6, 0x05, 0x45, 0xe9, 0x2c, 0xa4, + 0x7b, 0x34, 0xf8, 0x4f, 0x72, 0x52, 0x86, 0x5f, 0x9a, 0x87, 0xa1, 0x48, 0x75, 0xd2, 0x9d, 0xfc, + 0x2f, 0x71, 0xf2, 0x28, 0x15, 0x11, 0x9d, 0x57, 0x27, 0xdd, 0x19, 0x7c, 0x4c, 0x88, 0xce, 0x29, + 0x88, 0xd9, 0x44, 0x61, 0xd2, 0x9d, 0xfa, 0xe3, 0xc2, 0xea, 0x82, 0xa4, 0xf4, 0x14, 0x64, 0x83, + 0xc1, 0xa6, 0x3b, 0xfd, 0x4f, 0x71, 0xfa, 0x90, 0x86, 0x58, 0x20, 0x32, 0xd8, 0x75, 0x67, 0xf1, + 0xd3, 0xc2, 0x02, 0x11, 0x2a, 0x12, 0x46, 0xcd, 0x05, 0x4c, 0x77, 0x4e, 0x3f, 0x23, 0xc2, 0xa8, + 0xa9, 0x7e, 0x21, 0xbd, 0x49, 0x73, 0x7e, 0x77, 0x16, 0x3f, 0x2b, 0x7a, 0x93, 0xe2, 0x13, 0x31, + 0x9a, 0x2b, 0x82, 0xee, 0x3c, 0xfe, 0x8a, 0x10, 0xa3, 0xa9, 0x20, 0x28, 0xad, 0x03, 0x6a, 0xad, + 0x06, 0xba, 0xf3, 0xfb, 0x04, 0xe7, 0x37, 0xde, 0x52, 0x0c, 0x94, 0x9e, 0x81, 0x23, 0xed, 0x2b, + 0x81, 0xee, 0x5c, 0x3f, 0xf9, 0x4a, 0xd3, 0xdc, 0x2d, 0x5a, 0x08, 0x94, 0x36, 0xc3, 0x21, 0x25, + 0x5a, 0x05, 0x74, 0x67, 0xfb, 0xa9, 0x57, 0xe2, 0x89, 0x3b, 0x5a, 0x04, 0x94, 0xe6, 0x00, 0xc2, + 0x01, 0xb8, 0x3b, 0xaf, 0x4f, 0x73, 0x5e, 0x11, 0x22, 0x12, 0x1a, 0x7c, 0xfc, 0xed, 0x4e, 0xff, + 0x92, 0x08, 0x0d, 0x4e, 0x41, 0x42, 0x43, 0x0c, 0xbd, 0xdd, 0xa9, 0x3f, 0x23, 0x42, 0x43, 0x90, + 0x10, 0xcf, 0x8e, 0x8c, 0x6e, 0xdd, 0x39, 0x7c, 0x4e, 0x78, 0x76, 0x84, 0xaa, 0xb4, 0x0a, 0xe3, + 0x2d, 0x03, 0x62, 0x77, 0x56, 0x9f, 0xe7, 0xac, 0x72, 0xcd, 0xe3, 0x61, 0x74, 0xf0, 0xe2, 0x83, + 0x61, 0x77, 0x6e, 0x5f, 0x68, 0x1a, 0xbc, 0xf8, 0x58, 0x58, 0x3a, 0x0f, 0x19, 0xab, 0x61, 0x9a, + 0x24, 0x78, 0xd0, 0xfe, 0x67, 0xfe, 0xf2, 0x7f, 0xf8, 0x2a, 0xb7, 0x8e, 0x20, 0x28, 0x3d, 0x01, + 0x69, 0x5c, 0xdf, 0xc2, 0xd5, 0x6e, 0x94, 0xdf, 0x7b, 0x55, 0x24, 0x4c, 0x82, 0x5d, 0x7a, 0x0a, + 0x80, 0x2d, 0x8d, 0xd0, 0xed, 0xc1, 0x2e, 0xb4, 0xff, 0xf5, 0x55, 0x7e, 0x1a, 0x27, 0x24, 0x09, + 0x19, 0xb0, 0xb3, 0x3d, 0xfb, 0x33, 0xf8, 0x7e, 0x9c, 0x01, 0xed, 0x91, 0x27, 0x61, 0xf0, 0x39, + 0xcf, 0xb6, 0x7c, 0xad, 0xd6, 0x8d, 0xfa, 0xbf, 0x71, 0x6a, 0x81, 0x4f, 0x0c, 0x56, 0xb7, 0x5d, + 0xec, 0x6b, 0x35, 0xaf, 0x1b, 0xed, 0x7f, 0xe7, 0xb4, 0x01, 0x01, 0x21, 0xd6, 0x35, 0xcf, 0xef, + 0x45, 0xef, 0x3f, 0x12, 0xc4, 0x82, 0x80, 0x08, 0x4d, 0x9e, 0xaf, 0xe1, 0xbd, 0x6e, 0xb4, 0x7f, + 0x2c, 0x84, 0xe6, 0xf8, 0xa5, 0x77, 0x40, 0x96, 0x3c, 0xb2, 0x23, 0x76, 0x5d, 0x88, 0xff, 0x07, + 0x27, 0x0e, 0x29, 0x48, 0xcb, 0x9e, 0x5f, 0xf5, 0x8d, 0xee, 0xc6, 0xbe, 0xcd, 0x7b, 0x5a, 0xe0, + 0x97, 0xe6, 0x60, 0xc8, 0xf3, 0xab, 0xd5, 0x06, 0xaf, 0x4f, 0xbb, 0x90, 0xff, 0xcf, 0x57, 0x83, + 0x25, 0x8b, 0x80, 0x86, 0xf4, 0xf6, 0x8d, 0x6b, 0xbe, 0x63, 0xd3, 0x2d, 0x90, 0x6e, 0x1c, 0x5e, + 0xe1, 0x1c, 0x22, 0x24, 0xa5, 0x79, 0x18, 0x26, 0xba, 0xb8, 0xd8, 0xc1, 0x74, 0xbf, 0xaa, 0x0b, + 0x8b, 0xff, 0xc5, 0x0d, 0x10, 0x23, 0x2a, 0xff, 0x68, 0xa7, 0x7b, 0x37, 0xed, 0x97, 0x8d, 0x61, + 0xd1, 0x5e, 0xb4, 0xd9, 0x82, 0xf1, 0x7b, 0xe4, 0xd8, 0x72, 0x71, 0xcd, 0x0e, 0x57, 0x6b, 0x83, + 0x49, 0x0e, 0xfc, 0x66, 0x9a, 0x54, 0xcd, 0x74, 0x2d, 0x57, 0x73, 0x8c, 0xd9, 0x1d, 0xdf, 0x77, + 0xf8, 0x6a, 0x2f, 0x70, 0xd6, 0x9a, 0x63, 0xc8, 0x7b, 0x90, 0xba, 0xe8, 0xfb, 0x0e, 0x3a, 0x09, + 0x69, 0xb7, 0x61, 0x62, 0x8f, 0xaf, 0xb2, 0x4f, 0x16, 0x43, 0x9c, 0x22, 0x41, 0x50, 0x1a, 0x26, + 0x56, 0x18, 0x0a, 0xaa, 0xc0, 0xf4, 0x76, 0xc3, 0x34, 0xf7, 0xd4, 0x2a, 0xa6, 0x97, 0x2b, 0x82, + 0x73, 0x8c, 0x78, 0xd7, 0xd1, 0xc4, 0x66, 0x08, 0x31, 0xd9, 0x71, 0x8a, 0xb6, 0x40, 0xb1, 0xc4, + 0x19, 0xc6, 0x8a, 0xc0, 0x91, 0x7f, 0x3f, 0x01, 0x19, 0xc1, 0x1a, 0x15, 0x20, 0xe3, 0x61, 0x13, + 0xeb, 0xbe, 0xed, 0xf2, 0xc3, 0x65, 0xc1, 0x3b, 0x42, 0x90, 0xac, 0xf1, 0xdb, 0x52, 0xd9, 0x8b, + 0x87, 0x14, 0xf2, 0x42, 0x60, 0x4e, 0x83, 0x5d, 0x95, 0xa2, 0x30, 0xa7, 0xe1, 0xa3, 0x49, 0x48, + 0x39, 0xb6, 0xe7, 0xb3, 0x0d, 0x8a, 0x8b, 0x87, 0x14, 0xfa, 0x86, 0xf2, 0x30, 0x50, 0xc5, 0x26, + 0xf6, 0xd9, 0x0e, 0x13, 0x81, 0xf3, 0x77, 0x74, 0x04, 0xd2, 0x8e, 0xe6, 0xeb, 0x3b, 0xec, 0xe8, + 0xf4, 0xc5, 0x43, 0x0a, 0x7b, 0x45, 0x08, 0x52, 0x5b, 0x76, 0x75, 0x8f, 0x1f, 0x8a, 0xa6, 0xcf, + 0xe8, 0x2c, 0x0c, 0xb0, 0x68, 0x6f, 0x3e, 0xcd, 0x4c, 0x0c, 0xc4, 0x96, 0x55, 0x89, 0x2e, 0xeb, + 0x1a, 0xa9, 0xe0, 0x2d, 0xd2, 0x08, 0x43, 0x47, 0x15, 0x98, 0xd0, 0xaa, 0x55, 0x83, 0x38, 0x82, + 0x66, 0xaa, 0x5b, 0x86, 0x55, 0x35, 0xac, 0x9a, 0x47, 0x6f, 0xff, 0x74, 0x32, 0x33, 0x0a, 0x09, + 0xca, 0x1c, 0x9f, 0x1f, 0x17, 0xa5, 0x37, 0xbc, 0x54, 0x2a, 0x1c, 0xbb, 0x8b, 0x32, 0x2c, 0x80, + 0x65, 0xbb, 0xba, 0x57, 0xce, 0xc2, 0xa0, 0xc3, 0x04, 0x90, 0xcf, 0xc3, 0x78, 0x8b, 0x54, 0x44, + 0xb1, 0x6b, 0x86, 0x55, 0x15, 0xe7, 0x18, 0xc9, 0x33, 0x81, 0xd1, 0x6d, 0x10, 0xb6, 0xcf, 0x41, + 0x9f, 0xcb, 0x3f, 0x2e, 0x75, 0x74, 0xcd, 0xd1, 0x88, 0x6b, 0x6a, 0x8e, 0x51, 0xce, 0x52, 0xfe, + 0xc4, 0xad, 0xd6, 0xa5, 0xf7, 0xcc, 0xf1, 0x0f, 0x6c, 0x07, 0xa3, 0x68, 0xbb, 0xb5, 0xd9, 0x1a, + 0xb6, 0xc4, 0x6e, 0x03, 0xf9, 0xa4, 0x39, 0x86, 0x47, 0xdd, 0x31, 0xdc, 0x96, 0xf1, 0xce, 0x47, + 0x9e, 0xe9, 0x46, 0x46, 0x6a, 0x71, 0x6e, 0x7d, 0x29, 0xb8, 0x52, 0xf6, 0x1b, 0x09, 0x38, 0x1e, + 0xf1, 0xe3, 0x08, 0x72, 0xab, 0x3b, 0x17, 0xda, 0x7b, 0x7c, 0x0f, 0x9b, 0x1a, 0x97, 0x21, 0x45, + 0xf0, 0x51, 0x97, 0x53, 0x98, 0xf9, 0x5f, 0xfa, 0xe7, 0xff, 0x48, 0xa6, 0x0e, 0xd0, 0xbe, 0xeb, + 0x28, 0x93, 0xf2, 0x47, 0x7a, 0xb7, 0x5f, 0x2e, 0xdc, 0x91, 0xf2, 0xee, 0x9c, 0x19, 0x9b, 0x6d, + 0xf8, 0xf1, 0x04, 0x4c, 0x37, 0x9b, 0x80, 0x24, 0x53, 0xcf, 0xd7, 0xea, 0x4e, 0xa7, 0x5b, 0x79, + 0xe7, 0x21, 0xbb, 0x29, 0x70, 0x50, 0x1e, 0x06, 0x3d, 0xac, 0xdb, 0x56, 0xd5, 0xa3, 0xde, 0x93, + 0x54, 0xc4, 0x2b, 0x9a, 0x84, 0xb4, 0xa5, 0x59, 0xb6, 0xc7, 0x0f, 0x0d, 0xb3, 0x97, 0xf2, 0x5f, + 0x96, 0xfa, 0xcb, 0x6e, 0xa3, 0x41, 0x53, 0xc2, 0x0a, 0x0f, 0xed, 0xb7, 0x25, 0xc6, 0xee, 0x1e, + 0x06, 0x2a, 0x44, 0xf6, 0xbf, 0xa6, 0x9a, 0xf7, 0xbf, 0x9e, 0xc1, 0xa6, 0x79, 0xd9, 0xb2, 0x6f, + 0x58, 0x9b, 0x84, 0x26, 0x30, 0xc9, 0xef, 0x4a, 0x30, 0x43, 0x6f, 0x43, 0xb8, 0x75, 0xc3, 0xf2, + 0x67, 0x4d, 0x63, 0xcb, 0x9b, 0xdd, 0x32, 0x7c, 0x8f, 0x5d, 0x6b, 0xe4, 0x36, 0x99, 0x0c, 0x31, + 0x8a, 0x04, 0xa3, 0x48, 0x30, 0xe4, 0xd3, 0x90, 0x29, 0x1b, 0xfe, 0x9c, 0xeb, 0x6a, 0x7b, 0x34, + 0x57, 0x18, 0xbe, 0x30, 0x0a, 0x7d, 0x26, 0x16, 0xc1, 0x26, 0xae, 0x7b, 0x74, 0xe7, 0x35, 0xa5, + 0xb0, 0x97, 0xf2, 0x95, 0x8e, 0xd7, 0x2c, 0xcf, 0x47, 0x34, 0x8d, 0x88, 0x14, 0x79, 0x64, 0x7d, + 0xdf, 0x4e, 0xdc, 0x40, 0x9f, 0x2f, 0xa5, 0xe0, 0xee, 0x08, 0x82, 0xee, 0xee, 0x39, 0x3e, 0x1d, + 0x17, 0xec, 0x6d, 0xae, 0xcc, 0x78, 0x44, 0x19, 0xf6, 0xb9, 0xd0, 0x76, 0x37, 0x50, 0xde, 0x86, + 0xf4, 0x3a, 0xa1, 0x0b, 0xef, 0x8b, 0x32, 0xed, 0xd8, 0x0b, 0x81, 0xb2, 0x1b, 0x21, 0x09, 0x06, + 0x35, 0xc4, 0x65, 0x10, 0x13, 0x6b, 0xdb, 0xec, 0x04, 0x6e, 0x92, 0x6e, 0xc0, 0x67, 0x08, 0x80, + 0x1e, 0xb6, 0x9d, 0x84, 0xb4, 0xd6, 0x60, 0x7b, 0xc7, 0xc9, 0x13, 0xc3, 0x0a, 0x7b, 0x91, 0x2f, + 0xc3, 0x20, 0xdf, 0xaf, 0x6a, 0x73, 0x4b, 0xb6, 0x08, 0x69, 0x2a, 0x3c, 0xbf, 0x5a, 0x90, 0x2f, + 0xb6, 0x48, 0x5f, 0xa4, 0x42, 0x2a, 0x0c, 0x4d, 0xbe, 0x04, 0x99, 0x05, 0xbb, 0x6e, 0x58, 0x76, + 0x9c, 0x5b, 0x96, 0x71, 0xa3, 0x32, 0x93, 0x01, 0x83, 0xa5, 0x39, 0xf6, 0x42, 0x6f, 0xe2, 0xd2, + 0x13, 0xd9, 0x7c, 0xff, 0x9b, 0xbf, 0xc9, 0xf3, 0x30, 0x48, 0x79, 0xaf, 0x39, 0xa4, 0x7f, 0x83, + 0xd3, 0x70, 0x59, 0x7e, 0xed, 0x86, 0xb3, 0x4f, 0x84, 0xc2, 0x22, 0x48, 0x55, 0x35, 0x5f, 0xe3, + 0x7a, 0xd3, 0x67, 0xf9, 0x9d, 0x90, 0xe1, 0x4c, 0x3c, 0x74, 0x0a, 0x92, 0xb6, 0x23, 0xc6, 0xd6, + 0x42, 0x27, 0x55, 0xd6, 0x9c, 0x72, 0xea, 0x6b, 0xb7, 0xa6, 0x0f, 0x29, 0x04, 0xb9, 0xac, 0x74, + 0xf4, 0x97, 0x73, 0xfd, 0xfb, 0x0b, 0x6b, 0x26, 0x70, 0x96, 0xcf, 0x25, 0x60, 0x2a, 0xf2, 0xf5, + 0x3a, 0x76, 0xc9, 0x88, 0x1c, 0x73, 0x7d, 0x14, 0x11, 0x92, 0x7f, 0xef, 0xe0, 0x2e, 0xef, 0x80, + 0xe4, 0x9c, 0xe3, 0x90, 0x11, 0x9c, 0xed, 0x54, 0xdb, 0xcc, 0x5f, 0x52, 0x4a, 0xf0, 0x4e, 0x47, + 0x77, 0x7b, 0xdb, 0xbf, 0xa1, 0xb9, 0xc1, 0x5d, 0x24, 0xf1, 0x2e, 0x3f, 0x09, 0xd9, 0x79, 0x32, + 0x82, 0x59, 0x5e, 0x83, 0x86, 0xce, 0x96, 0x69, 0xeb, 0xd7, 0x38, 0x07, 0xf6, 0x42, 0x0c, 0xae, + 0x39, 0x0e, 0xbf, 0xb5, 0x4c, 0x1e, 0x4b, 0xa9, 0xef, 0x7e, 0x76, 0x5a, 0x2a, 0x6f, 0x74, 0x34, + 0xd1, 0x93, 0xfd, 0x9b, 0x88, 0x2b, 0x19, 0xd8, 0xe8, 0xd7, 0x8f, 0xc2, 0xf1, 0x28, 0x29, 0xcb, + 0x38, 0x11, 0x0b, 0xe5, 0x22, 0x16, 0xa2, 0xf0, 0xf6, 0xf6, 0x29, 0x74, 0xcb, 0xbc, 0x85, 0xae, + 0x79, 0xa8, 0xb0, 0x7f, 0x64, 0x17, 0xba, 0xf4, 0xa5, 0xfc, 0x24, 0x8c, 0xac, 0x6b, 0xae, 0xbf, + 0x81, 0xfd, 0x8b, 0x58, 0xab, 0x62, 0x37, 0x1e, 0xd8, 0x23, 0x22, 0xb0, 0x11, 0xa4, 0x68, 0xf4, + 0x32, 0xc7, 0xa6, 0xcf, 0xf2, 0x0e, 0xa4, 0xe8, 0x69, 0x97, 0x20, 0xe8, 0x39, 0x05, 0x0b, 0x7a, + 0xd2, 0x5d, 0x7b, 0x3e, 0xf6, 0x38, 0x09, 0x7b, 0x41, 0xa7, 0x45, 0xe8, 0x26, 0xf7, 0x0f, 0x5d, + 0xee, 0xed, 0x3c, 0x80, 0x4d, 0x18, 0x2c, 0x93, 0xde, 0x5e, 0x5a, 0x08, 0x04, 0x91, 0x42, 0x41, + 0xd0, 0x0a, 0x8c, 0x39, 0x9a, 0xeb, 0xd3, 0x63, 0xbe, 0x3b, 0x54, 0x0b, 0x9e, 0x19, 0xa6, 0x8b, + 0xcd, 0xfd, 0x50, 0x8c, 0x29, 0xcb, 0x5b, 0x19, 0x71, 0xa2, 0x40, 0xf9, 0x3f, 0xa7, 0x60, 0x80, + 0x1b, 0xe3, 0x1d, 0x30, 0xc8, 0x8d, 0x46, 0x1b, 0x24, 0xb5, 0x5d, 0xab, 0xef, 0x17, 0x03, 0x1f, + 0xe5, 0xfc, 0x04, 0x0d, 0xba, 0x1f, 0x32, 0xfa, 0x8e, 0x66, 0x58, 0xaa, 0xc1, 0xce, 0xbb, 0x66, + 0xcb, 0x43, 0x2f, 0xdf, 0x9a, 0x1e, 0x9c, 0x27, 0xb0, 0xa5, 0x05, 0x65, 0x90, 0x7e, 0x5c, 0xaa, + 0x92, 0x64, 0xb3, 0x83, 0x8d, 0xda, 0x0e, 0x4b, 0x36, 0x49, 0x85, 0xbf, 0xa1, 0x73, 0x90, 0x22, + 0x0e, 0xc1, 0x6f, 0x81, 0x14, 0x5a, 0xea, 0x8f, 0x60, 0x60, 0x2c, 0x67, 0x48, 0xc3, 0x1f, 0xff, + 0xd6, 0xb4, 0xa4, 0x50, 0x0a, 0x34, 0x0f, 0x23, 0xa6, 0xe6, 0xf9, 0x2a, 0x0d, 0x12, 0xd2, 0x7c, + 0x9a, 0xb2, 0x38, 0xda, 0x6a, 0x10, 0x6e, 0x58, 0x2e, 0xfa, 0x10, 0xa1, 0x62, 0xa0, 0x2a, 0x3a, + 0x01, 0x39, 0xca, 0x44, 0xb7, 0xeb, 0x75, 0xc3, 0x67, 0xe9, 0x7b, 0x80, 0xda, 0x7d, 0x94, 0xc0, + 0xe7, 0x29, 0x98, 0x26, 0xf1, 0x63, 0x90, 0xa5, 0xc7, 0xce, 0x29, 0x0a, 0x3b, 0x62, 0x95, 0x21, + 0x00, 0xfa, 0xf1, 0x01, 0x18, 0xbb, 0xae, 0x99, 0x46, 0x55, 0xf3, 0x6d, 0xd7, 0x63, 0x28, 0x19, + 0xc6, 0x25, 0x04, 0x53, 0xc4, 0x47, 0x61, 0x92, 0xfe, 0x3c, 0x41, 0x33, 0x76, 0x96, 0x62, 0x23, + 0xf2, 0xed, 0x6a, 0x9c, 0xe2, 0x6d, 0xa4, 0x68, 0xe2, 0xc6, 0x67, 0xb8, 0x40, 0x71, 0x47, 0x02, + 0x28, 0x45, 0x3b, 0x0a, 0x19, 0xcd, 0x71, 0x18, 0xc2, 0x10, 0xfb, 0xdd, 0x03, 0xcd, 0x71, 0xe8, + 0xa7, 0x93, 0x30, 0x4e, 0x75, 0x74, 0xb1, 0xd7, 0x30, 0x7d, 0xce, 0x64, 0x98, 0xe2, 0x8c, 0x91, + 0x0f, 0x0a, 0x83, 0x53, 0xdc, 0x7b, 0x61, 0x04, 0x5f, 0x37, 0xaa, 0xd8, 0xd2, 0x31, 0xc3, 0x1b, + 0xa1, 0x78, 0xc3, 0x02, 0x48, 0x91, 0x1e, 0x84, 0x9c, 0xe3, 0xda, 0x8e, 0xed, 0x61, 0x57, 0xd5, + 0xaa, 0x55, 0x17, 0x7b, 0x5e, 0x7e, 0x94, 0xf1, 0x13, 0xf0, 0x39, 0x06, 0x96, 0x1f, 0x86, 0xd4, + 0x82, 0xe6, 0x6b, 0x24, 0x87, 0xf9, 0xbb, 0x6c, 0x08, 0x18, 0x56, 0xc8, 0x63, 0xdb, 0x70, 0xfb, + 0x6e, 0x02, 0x52, 0x57, 0x6d, 0x1f, 0xa3, 0xc7, 0x23, 0xe3, 0xce, 0x68, 0x3b, 0x1f, 0xdf, 0x30, + 0x6a, 0x16, 0xae, 0xae, 0x78, 0xb5, 0xc8, 0x7d, 0xd0, 0xd0, 0xc5, 0x12, 0x31, 0x17, 0x9b, 0x84, + 0xb4, 0x6b, 0x37, 0xac, 0xaa, 0x38, 0xb1, 0x44, 0x5f, 0x50, 0x05, 0x32, 0x81, 0xe7, 0xa4, 0xba, + 0x79, 0xce, 0x18, 0xf1, 0x1c, 0xe2, 0xd7, 0x1c, 0xa0, 0x0c, 0x6e, 0x71, 0x07, 0x2a, 0x43, 0x36, + 0x48, 0x68, 0xdc, 0x03, 0x7b, 0x73, 0xe2, 0x90, 0x0c, 0x3d, 0x04, 0xe3, 0x81, 0x3f, 0x04, 0x06, + 0x65, 0x5e, 0x98, 0x0b, 0x3e, 0x70, 0x8b, 0xc6, 0x5c, 0x8d, 0xdf, 0x4d, 0x1d, 0xa4, 0x7a, 0x85, + 0xae, 0xc6, 0xee, 0xa7, 0x1e, 0x87, 0xac, 0x67, 0xd4, 0x2c, 0xcd, 0x6f, 0xb8, 0x98, 0x7b, 0x63, + 0x08, 0x90, 0x7f, 0x2a, 0x01, 0x03, 0xcc, 0xbb, 0x23, 0x76, 0x93, 0xda, 0xdb, 0x2d, 0xd1, 0xc9, + 0x6e, 0xc9, 0x83, 0xdb, 0x6d, 0x0e, 0x20, 0x10, 0xc6, 0xe3, 0x77, 0x0b, 0x8f, 0xb5, 0x32, 0x62, + 0x22, 0x6e, 0x18, 0x35, 0x1e, 0xbc, 0x11, 0xa2, 0xc0, 0x83, 0xd2, 0x91, 0x3c, 0x79, 0x1e, 0xb2, + 0x5b, 0x86, 0xaf, 0x6a, 0xa4, 0x3a, 0xa5, 0x26, 0x1c, 0x3a, 0x35, 0x55, 0x6c, 0x57, 0xc6, 0x16, + 0x45, 0x0d, 0xab, 0x64, 0xb6, 0xf8, 0x93, 0xfc, 0x1f, 0x25, 0x32, 0x18, 0xf3, 0x06, 0xd1, 0x1c, + 0x8c, 0x08, 0x45, 0xd5, 0x6d, 0x53, 0xab, 0x71, 0x67, 0xbc, 0xbb, 0xa3, 0xb6, 0x17, 0x4c, 0xad, + 0xa6, 0x0c, 0x71, 0x05, 0xc9, 0x4b, 0xfb, 0x8e, 0x4d, 0x74, 0xe8, 0xd8, 0x98, 0x27, 0x25, 0x0f, + 0xe6, 0x49, 0xb1, 0x3e, 0x4f, 0x35, 0xf7, 0xf9, 0x97, 0x13, 0xb4, 0x28, 0x73, 0x6c, 0x4f, 0x33, + 0xdf, 0x88, 0x10, 0x3b, 0x06, 0x59, 0xc7, 0x36, 0x55, 0xf6, 0x85, 0x1d, 0x0d, 0xcc, 0x38, 0xb6, + 0xa9, 0xb4, 0xf8, 0x51, 0xfa, 0x0e, 0xc5, 0xdf, 0xc0, 0x1d, 0xb0, 0xda, 0x60, 0xb3, 0xd5, 0x5c, + 0x18, 0x66, 0xa6, 0xe0, 0x03, 0xe6, 0xa3, 0xc4, 0x06, 0x74, 0x04, 0x96, 0x5a, 0x07, 0x78, 0x26, + 0x36, 0xc3, 0x54, 0x38, 0x1e, 0xa1, 0x60, 0xe3, 0x4b, 0xbb, 0x6a, 0x3e, 0xea, 0xe7, 0x0a, 0xc7, + 0x93, 0xff, 0xa9, 0x04, 0x59, 0xaa, 0xea, 0x0a, 0xf6, 0xb5, 0x98, 0xa9, 0xa4, 0x83, 0x9b, 0xea, + 0x6e, 0x00, 0xc6, 0xc6, 0x33, 0x6e, 0x62, 0xde, 0x81, 0x59, 0x0a, 0xd9, 0x30, 0x6e, 0x62, 0x74, + 0x26, 0xd0, 0x2b, 0xb9, 0xbf, 0x5e, 0x3c, 0x14, 0x85, 0x76, 0x77, 0xc1, 0x20, 0xfd, 0x69, 0x8c, + 0x5d, 0x76, 0x36, 0x36, 0x49, 0x2f, 0xce, 0x6e, 0xee, 0x7a, 0xf2, 0x73, 0x30, 0xb8, 0xb9, 0xcb, + 0xa6, 0x52, 0xc7, 0x20, 0xeb, 0xda, 0x36, 0x1f, 0x5f, 0x59, 0x5d, 0x93, 0x21, 0x00, 0x3a, 0x9c, + 0x88, 0xe9, 0x43, 0x22, 0x9c, 0x3e, 0x84, 0xf3, 0x9f, 0x64, 0x4f, 0xf3, 0x9f, 0x93, 0xff, 0x4e, + 0x82, 0xa1, 0x48, 0x18, 0xa2, 0xc7, 0xe0, 0x70, 0x79, 0x79, 0x6d, 0xfe, 0xb2, 0xba, 0xb4, 0xa0, + 0x5e, 0x58, 0x9e, 0x5b, 0x0c, 0xcf, 0x98, 0x17, 0x8e, 0xbc, 0xf8, 0xd2, 0x0c, 0x8a, 0xe0, 0x5e, + 0xb1, 0xae, 0x91, 0xf9, 0x31, 0x9a, 0x85, 0xc9, 0x38, 0xc9, 0x5c, 0x79, 0xa3, 0xb2, 0xba, 0x99, + 0x93, 0x0a, 0x87, 0x5f, 0x7c, 0x69, 0x66, 0x3c, 0x42, 0x31, 0xb7, 0xe5, 0x61, 0xcb, 0x6f, 0x25, + 0x98, 0x5f, 0x5b, 0x59, 0x59, 0xda, 0xcc, 0x25, 0x5a, 0x08, 0x78, 0xa2, 0x7d, 0x10, 0xc6, 0xe3, + 0x04, 0xab, 0x4b, 0xcb, 0xb9, 0x64, 0x01, 0xbd, 0xf8, 0xd2, 0xcc, 0x68, 0x04, 0x7b, 0xd5, 0x30, + 0x0b, 0x99, 0x9f, 0xf8, 0xc2, 0xd4, 0xa1, 0x9f, 0xff, 0x6b, 0x53, 0x12, 0xd1, 0x6c, 0x24, 0x16, + 0x8a, 0xe8, 0x61, 0xb8, 0x6b, 0x63, 0x69, 0x71, 0xb5, 0xb2, 0xa0, 0xae, 0x6c, 0x2c, 0xaa, 0xec, + 0x72, 0x7d, 0xa0, 0xdd, 0xd8, 0x8b, 0x2f, 0xcd, 0x0c, 0x71, 0x95, 0x3a, 0x61, 0xaf, 0x2b, 0x95, + 0xab, 0x6b, 0x9b, 0x95, 0x9c, 0xc4, 0xb0, 0xd7, 0x5d, 0x7c, 0xdd, 0xf6, 0xd9, 0x6f, 0xe7, 0x3c, + 0x0a, 0x47, 0xdb, 0x60, 0x07, 0x8a, 0x8d, 0xbf, 0xf8, 0xd2, 0xcc, 0xc8, 0xba, 0x8b, 0x99, 0x9b, + 0x52, 0x8a, 0x22, 0xe4, 0x5b, 0x29, 0xd6, 0xd6, 0xd7, 0x36, 0xe6, 0x96, 0x73, 0x33, 0x85, 0xdc, + 0x8b, 0x2f, 0xcd, 0x0c, 0x8b, 0x9c, 0x43, 0xf0, 0x43, 0xcd, 0xca, 0x4f, 0x77, 0x9c, 0xbf, 0x9c, + 0xed, 0x7f, 0xfe, 0xe2, 0xc7, 0x96, 0x37, 0xfe, 0x62, 0x02, 0xa6, 0x5a, 0x16, 0xbd, 0xf8, 0xfa, + 0x77, 0xa7, 0x05, 0x9f, 0x12, 0x64, 0x16, 0xc4, 0xb2, 0x7a, 0xbf, 0xeb, 0x3d, 0x3f, 0xdb, 0xe7, + 0x7a, 0xcf, 0x88, 0x68, 0x49, 0x2c, 0xf7, 0x9c, 0xec, 0xbe, 0xdc, 0x23, 0xe4, 0x3f, 0xc0, 0x6a, + 0xcf, 0x87, 0x92, 0x30, 0x15, 0xfd, 0x79, 0x2f, 0xf1, 0xc3, 0x5e, 0xba, 0x6d, 0x08, 0x73, 0x4c, + 0x44, 0x7f, 0xd2, 0x8b, 0x7f, 0xef, 0x30, 0xe3, 0x5d, 0x84, 0xd4, 0xbc, 0x6d, 0x58, 0xc4, 0x14, + 0x55, 0x6c, 0xd9, 0x75, 0xbe, 0x3a, 0xc0, 0x5e, 0xd0, 0xbd, 0x30, 0xa0, 0xd5, 0xed, 0x86, 0xe5, + 0x8b, 0xe9, 0x00, 0x49, 0x16, 0xbf, 0x7f, 0x6b, 0x3a, 0xb9, 0x64, 0xf9, 0x0a, 0xff, 0xc4, 0x26, + 0xb0, 0xf2, 0x25, 0x18, 0x5c, 0xc0, 0xfa, 0x41, 0x78, 0x2d, 0x60, 0xbd, 0x89, 0xd7, 0x83, 0x90, + 0x59, 0xb2, 0x7c, 0x76, 0x61, 0xfd, 0x6e, 0x48, 0x1a, 0x16, 0xab, 0x66, 0x9a, 0xda, 0x27, 0x70, + 0x82, 0xba, 0x80, 0xf5, 0x00, 0xb5, 0x8a, 0xf5, 0x66, 0x54, 0xc2, 0x9e, 0xc0, 0xcb, 0x0b, 0xbf, + 0xf7, 0x9f, 0xa6, 0x0e, 0xbd, 0xf0, 0xf2, 0xd4, 0xa1, 0x8e, 0xae, 0x2a, 0x77, 0xff, 0x91, 0xb0, + 0xa0, 0x1b, 0x3e, 0xfc, 0x18, 0xdc, 0xc7, 0x71, 0x3c, 0x5f, 0xbb, 0x66, 0x58, 0xb5, 0xa0, 0x27, + 0xf8, 0x3b, 0xef, 0x8c, 0x23, 0xbc, 0x33, 0x04, 0x74, 0xdf, 0xfe, 0x28, 0xec, 0x3b, 0x4f, 0xef, + 0x3e, 0xff, 0xee, 0x12, 0x28, 0x85, 0x2e, 0x9e, 0x23, 0x7f, 0x54, 0x82, 0xd1, 0x8b, 0x86, 0xe7, + 0xdb, 0xae, 0xa1, 0x6b, 0x26, 0xbd, 0xb9, 0x70, 0xa6, 0xd7, 0x21, 0xb2, 0x69, 0x28, 0x79, 0x0a, + 0x06, 0xae, 0x6b, 0x26, 0xfb, 0x6d, 0xb8, 0x24, 0xfd, 0xa5, 0x85, 0xf6, 0x86, 0x28, 0x06, 0x73, + 0x24, 0xc1, 0x80, 0x91, 0xc9, 0xbf, 0x98, 0x80, 0x31, 0x9a, 0x6c, 0x3d, 0xf6, 0xd3, 0x3a, 0x64, + 0x3e, 0x5e, 0x86, 0x94, 0xab, 0xf9, 0x7c, 0x0d, 0xab, 0x5c, 0xe4, 0x7d, 0x7c, 0x7f, 0xf7, 0x7e, + 0x2b, 0x12, 0x37, 0xa0, 0xb4, 0xe8, 0x47, 0x20, 0x53, 0xd7, 0x76, 0x55, 0xca, 0x87, 0xb9, 0xe2, + 0x5c, 0x7f, 0x7c, 0x6e, 0xdf, 0x9a, 0x1e, 0xdb, 0xd3, 0xea, 0x66, 0x49, 0x16, 0x7c, 0x64, 0x65, + 0xb0, 0xae, 0xed, 0x12, 0x11, 0x91, 0x03, 0x63, 0x04, 0xaa, 0xef, 0x68, 0x56, 0x0d, 0xb3, 0x46, + 0xe8, 0x8a, 0x5c, 0xf9, 0x62, 0xdf, 0x8d, 0x1c, 0x09, 0x1b, 0x89, 0xb0, 0x93, 0x95, 0x91, 0xba, + 0xb6, 0x3b, 0x4f, 0x01, 0xa4, 0xc5, 0x52, 0xe6, 0x13, 0x9f, 0x9d, 0x3e, 0x44, 0xe3, 0xe6, 0x1b, + 0x12, 0x40, 0x68, 0x31, 0xf4, 0x23, 0x90, 0xd3, 0x83, 0x37, 0x4a, 0xeb, 0xf1, 0x3e, 0x7c, 0xa0, + 0x53, 0x5f, 0x34, 0xd9, 0x9b, 0x95, 0x58, 0x5f, 0xbf, 0x35, 0x2d, 0x29, 0x63, 0x7a, 0x53, 0x57, + 0xbc, 0x17, 0x86, 0x1a, 0x4e, 0x55, 0xf3, 0xb1, 0x4a, 0xe7, 0xfc, 0x89, 0xae, 0xe5, 0xda, 0x14, + 0xe1, 0x75, 0xfb, 0xd6, 0x34, 0x62, 0x6a, 0x45, 0x88, 0x65, 0x5a, 0xc4, 0x01, 0x83, 0x10, 0x82, + 0x88, 0x4e, 0xbf, 0x23, 0xc1, 0xd0, 0x42, 0xe4, 0x04, 0x51, 0x1e, 0x06, 0xeb, 0xb6, 0x65, 0x5c, + 0xc3, 0x62, 0x73, 0x4d, 0xbc, 0xa2, 0x02, 0x64, 0xd8, 0x65, 0x2e, 0x7f, 0x4f, 0xac, 0xcc, 0x89, + 0x77, 0x42, 0x75, 0x03, 0x6f, 0x79, 0x86, 0xe8, 0x0d, 0x45, 0xbc, 0xa2, 0x0b, 0x90, 0xf3, 0xb0, + 0xde, 0x70, 0x0d, 0x7f, 0x4f, 0xd5, 0x6d, 0xcb, 0xd7, 0x74, 0xbe, 0xeb, 0x56, 0x3e, 0x76, 0xfb, + 0xd6, 0xf4, 0x5d, 0x4c, 0xd6, 0x66, 0x0c, 0x59, 0x19, 0x13, 0xa0, 0x79, 0x06, 0x21, 0x2d, 0x54, + 0xb1, 0xaf, 0x19, 0xa6, 0xc7, 0x36, 0xe7, 0x14, 0xf1, 0x1a, 0xd1, 0xe5, 0x1f, 0x0f, 0x42, 0x36, + 0xf0, 0x76, 0x74, 0x03, 0x72, 0xb6, 0x83, 0xdd, 0xd8, 0x7c, 0x82, 0x96, 0x53, 0xe5, 0xe5, 0xb0, + 0xe5, 0x66, 0x0c, 0xf9, 0xff, 0xdf, 0x9a, 0x7e, 0xa4, 0x07, 0x0f, 0xba, 0xaa, 0x99, 0x7c, 0x2e, + 0xa2, 0x8c, 0x09, 0x1e, 0x62, 0x72, 0x72, 0x81, 0xf8, 0x85, 0x58, 0x85, 0x70, 0x1a, 0x5b, 0x62, + 0x05, 0x38, 0xa6, 0x72, 0x33, 0x86, 0x4c, 0x3c, 0x80, 0x83, 0xd6, 0x29, 0x84, 0x4c, 0x20, 0x9e, + 0xd3, 0x0c, 0x53, 0xdc, 0x70, 0x55, 0xf8, 0x1b, 0x5a, 0x82, 0x01, 0xcf, 0xd7, 0xfc, 0x06, 0xab, + 0x21, 0xd3, 0xe5, 0xc7, 0x7a, 0x94, 0xb9, 0x6c, 0x5b, 0xd5, 0x0d, 0x4a, 0xa8, 0x70, 0x06, 0xe8, + 0x02, 0x0c, 0xf8, 0xf6, 0x35, 0x6c, 0x71, 0xa3, 0xf6, 0x15, 0xf1, 0x74, 0x8c, 0x62, 0xd4, 0xc8, + 0x87, 0x5c, 0x15, 0x9b, 0xb8, 0x46, 0x4d, 0xe9, 0xed, 0x68, 0x64, 0x9e, 0x4a, 0xb7, 0x4a, 0xcb, + 0x4b, 0x7d, 0x87, 0x25, 0x37, 0x50, 0x33, 0x3f, 0x59, 0x19, 0x0b, 0x40, 0x1b, 0x14, 0x82, 0x2e, + 0xc7, 0x0e, 0xbf, 0xf1, 0x9f, 0x62, 0xbb, 0xb7, 0x53, 0xec, 0x45, 0xbc, 0x5c, 0xac, 0x6e, 0x45, + 0x8f, 0xce, 0x5d, 0x80, 0x5c, 0xc3, 0xda, 0xb2, 0xe9, 0x26, 0xaa, 0xca, 0x27, 0x6e, 0x19, 0x52, + 0xcf, 0x44, 0x7b, 0xad, 0x19, 0x43, 0x56, 0xc6, 0x02, 0xd0, 0x45, 0x36, 0xbd, 0xab, 0xc2, 0x68, + 0x88, 0x45, 0x43, 0x37, 0xdb, 0x35, 0x74, 0xef, 0xe1, 0xa1, 0x7b, 0xb8, 0xb9, 0x95, 0x30, 0x7a, + 0x47, 0x02, 0x20, 0x21, 0x43, 0x17, 0x01, 0xc2, 0x84, 0x41, 0x57, 0xb9, 0x86, 0x4e, 0xc9, 0xdd, + 0xb3, 0x8e, 0x58, 0x19, 0x08, 0x69, 0xd1, 0xfb, 0x61, 0xa2, 0x6e, 0x58, 0xaa, 0x87, 0xcd, 0x6d, + 0x95, 0x1b, 0x98, 0xb0, 0xa4, 0xbf, 0x2a, 0x52, 0x5e, 0xee, 0xcf, 0x1f, 0x6e, 0xdf, 0x9a, 0x2e, + 0xf0, 0xa4, 0xda, 0xca, 0x52, 0x56, 0xc6, 0xeb, 0x86, 0xb5, 0x81, 0xcd, 0xed, 0x85, 0x00, 0x56, + 0x1a, 0xfe, 0x89, 0xcf, 0x4e, 0x1f, 0x0a, 0x02, 0xd8, 0x80, 0xe1, 0x30, 0xb0, 0xb0, 0x87, 0xd6, + 0x20, 0xab, 0x89, 0x17, 0xb6, 0x1e, 0xd6, 0xb3, 0xb3, 0x47, 0x02, 0x34, 0xe4, 0xc1, 0x72, 0xc5, + 0x0b, 0xff, 0x61, 0x46, 0x92, 0x5f, 0x4c, 0xc0, 0xc0, 0xc2, 0xd5, 0x75, 0xcd, 0x70, 0xd1, 0x4d, + 0x18, 0x0f, 0x9d, 0x2d, 0x9e, 0x29, 0x56, 0x6e, 0xdf, 0x9a, 0xce, 0x37, 0xfb, 0x63, 0x9f, 0xa9, + 0x62, 0x4e, 0xd7, 0x85, 0x24, 0x61, 0x90, 0x88, 0x5c, 0x71, 0xb3, 0xe3, 0xaa, 0x47, 0xb4, 0xed, + 0x16, 0x94, 0x03, 0xa4, 0xa9, 0x96, 0x45, 0x94, 0x48, 0xe2, 0xac, 0xc0, 0x20, 0xb3, 0x85, 0x87, + 0x4a, 0x90, 0x76, 0xc8, 0x03, 0xdf, 0x81, 0x9a, 0xea, 0x18, 0x4d, 0x14, 0x3f, 0x58, 0x97, 0x27, + 0x24, 0xf2, 0xe7, 0x93, 0x00, 0x0b, 0x57, 0xaf, 0x6e, 0xba, 0x86, 0x63, 0x62, 0xff, 0x07, 0x6a, + 0xd7, 0x0f, 0x4b, 0x70, 0x38, 0xb4, 0x9a, 0xe7, 0xea, 0x4d, 0xc6, 0x7d, 0xfa, 0xf6, 0xad, 0xe9, + 0xe3, 0xcd, 0xc6, 0x8d, 0xa0, 0x1d, 0xc0, 0xc0, 0x13, 0x01, 0xa3, 0x0d, 0x57, 0x6f, 0x2f, 0x47, + 0xd5, 0xf3, 0x03, 0x39, 0x92, 0x9d, 0xe5, 0x88, 0xa0, 0xbd, 0x26, 0x39, 0x16, 0x3c, 0xbf, 0xb5, + 0xaf, 0x37, 0x60, 0x28, 0xec, 0x23, 0x0f, 0x2d, 0x40, 0xc6, 0xe7, 0xcf, 0xbc, 0xcb, 0xe5, 0xce, + 0x5d, 0x2e, 0xc8, 0x78, 0xb7, 0x07, 0x94, 0xf2, 0xbf, 0x4d, 0x00, 0x84, 0x51, 0xfd, 0x67, 0x35, + 0xa2, 0xc8, 0x70, 0xca, 0x07, 0xbf, 0xe4, 0x81, 0x0a, 0x68, 0x4e, 0x1d, 0xe9, 0xad, 0x3f, 0x4c, + 0xc0, 0xc4, 0x15, 0x91, 0xf9, 0xdf, 0xb2, 0x30, 0x5a, 0x87, 0x41, 0x6c, 0xf9, 0xae, 0x41, 0x4d, + 0x4c, 0xbc, 0xf5, 0xd1, 0x4e, 0xde, 0xda, 0xc6, 0x6a, 0xf4, 0x87, 0x73, 0xc4, 0xa6, 0x1c, 0x67, + 0x13, 0xb1, 0xf5, 0xc7, 0x92, 0x90, 0xef, 0x44, 0x85, 0xe6, 0x61, 0x4c, 0x77, 0x31, 0x05, 0xa8, + 0xd1, 0x1d, 0x80, 0x72, 0x21, 0x9c, 0x49, 0x34, 0x21, 0xc8, 0xca, 0xa8, 0x80, 0xf0, 0xda, 0xa0, + 0x06, 0xa4, 0xcc, 0x27, 0x21, 0x43, 0xb0, 0x7a, 0xac, 0xeb, 0x65, 0x5e, 0x1c, 0x88, 0x46, 0xe2, + 0x0c, 0x58, 0x75, 0x30, 0x1a, 0x42, 0x69, 0x79, 0xf0, 0x3c, 0x8c, 0x19, 0x96, 0xe1, 0x1b, 0x9a, + 0xa9, 0x6e, 0x69, 0xa6, 0x66, 0xe9, 0x07, 0x99, 0x25, 0xb1, 0x01, 0x9d, 0x37, 0xdb, 0xc4, 0x4e, + 0x56, 0x46, 0x39, 0xa4, 0xcc, 0x00, 0xe8, 0x22, 0x0c, 0x8a, 0xa6, 0x52, 0x07, 0xaa, 0x25, 0x05, + 0x79, 0xa4, 0x47, 0x7e, 0x32, 0x09, 0xe3, 0x0a, 0xae, 0xbe, 0xd5, 0x15, 0xfd, 0x75, 0xc5, 0x0a, + 0x00, 0x4b, 0x24, 0x64, 0x24, 0x39, 0x40, 0x6f, 0x90, 0x54, 0x94, 0x65, 0x1c, 0x16, 0x3c, 0x3f, + 0xd2, 0x1f, 0x7f, 0x94, 0x84, 0xe1, 0x68, 0x7f, 0xbc, 0x35, 0xc4, 0xff, 0xf0, 0x0c, 0xf1, 0x68, + 0x29, 0x4c, 0x8d, 0x29, 0xfe, 0x03, 0xa8, 0x1d, 0x52, 0x63, 0x4b, 0x48, 0x75, 0xce, 0x89, 0xff, + 0x3b, 0x01, 0x03, 0xeb, 0x9a, 0xab, 0xd5, 0x3d, 0xa4, 0xb7, 0x4c, 0x6c, 0xc4, 0xfe, 0x4a, 0xcb, + 0x2f, 0x57, 0xf3, 0x45, 0xb1, 0x2e, 0xf3, 0x9a, 0x4f, 0xb4, 0x99, 0xd7, 0xbc, 0x0b, 0x46, 0xeb, + 0xda, 0x6e, 0x64, 0xcb, 0x9f, 0x76, 0xe6, 0x48, 0xf9, 0x68, 0xc8, 0x25, 0xfe, 0x9d, 0x2d, 0xd7, + 0x84, 0xe7, 0x00, 0xd0, 0x59, 0x18, 0x22, 0x18, 0xe1, 0x28, 0x41, 0xc8, 0x8f, 0x84, 0xeb, 0x22, + 0x91, 0x8f, 0xb2, 0x02, 0x75, 0x6d, 0xb7, 0xc2, 0x5e, 0xd0, 0x32, 0xa0, 0x9d, 0x60, 0x69, 0x4e, + 0x0d, 0x4d, 0x49, 0xe8, 0xef, 0xbe, 0x7d, 0x6b, 0xfa, 0x28, 0xa3, 0x6f, 0xc5, 0x91, 0x95, 0xf1, + 0x10, 0x28, 0xb8, 0x9d, 0x06, 0x20, 0x7a, 0xa9, 0x6c, 0xa5, 0x96, 0xcd, 0xae, 0x0f, 0xdf, 0xbe, + 0x35, 0x3d, 0xce, 0xb8, 0x84, 0xdf, 0x64, 0x25, 0x4b, 0x5e, 0x16, 0xc8, 0x73, 0xc4, 0xf0, 0x5f, + 0x90, 0x00, 0x85, 0x63, 0x50, 0xf0, 0x2f, 0x1b, 0x2e, 0x02, 0x44, 0x26, 0x69, 0xd2, 0xfe, 0xf3, + 0xbe, 0x90, 0x5e, 0xcc, 0xfb, 0x22, 0xa1, 0xfb, 0x64, 0x98, 0xaf, 0x13, 0xbc, 0x1f, 0xdb, 0x2c, + 0x6b, 0x17, 0xe7, 0x6d, 0x43, 0x50, 0xb7, 0x49, 0xd0, 0xff, 0x42, 0x82, 0xa3, 0x2d, 0xde, 0x14, + 0x08, 0xfb, 0xe7, 0x00, 0xb9, 0x91, 0x8f, 0xfc, 0x87, 0xec, 0x98, 0xd0, 0x7d, 0x3b, 0xe7, 0xb8, + 0xdb, 0x32, 0x10, 0xdc, 0xb9, 0x21, 0x87, 0xad, 0x8b, 0xff, 0x13, 0x09, 0x26, 0xa3, 0xcd, 0x07, + 0x8a, 0xac, 0xc2, 0x70, 0xb4, 0x75, 0xae, 0xc2, 0x7d, 0xbd, 0xa8, 0xc0, 0xa5, 0x8f, 0xd1, 0xa3, + 0xa7, 0xc3, 0x50, 0x65, 0x8b, 0xb7, 0x8f, 0xf5, 0x6c, 0x0d, 0x21, 0x53, 0x73, 0xc8, 0x32, 0x0d, + 0xfe, 0x44, 0x82, 0xd4, 0xba, 0x6d, 0x9b, 0xc8, 0x86, 0x71, 0xcb, 0xf6, 0x55, 0xe2, 0x59, 0xb8, + 0xaa, 0xf2, 0x35, 0x1e, 0xb6, 0xaa, 0x3b, 0xdf, 0x9f, 0x91, 0xbe, 0x77, 0x6b, 0xba, 0x95, 0x95, + 0x32, 0x66, 0xd9, 0x7e, 0x99, 0x42, 0x36, 0xd9, 0x0a, 0xd0, 0xfb, 0x61, 0x24, 0xde, 0x18, 0x5b, + 0xf1, 0x7a, 0xa6, 0xef, 0xc6, 0xe2, 0x6c, 0x6e, 0xdf, 0x9a, 0x9e, 0x0c, 0x23, 0x26, 0x00, 0xcb, + 0xca, 0xf0, 0x56, 0xa4, 0xf5, 0x52, 0x86, 0x68, 0xff, 0xc7, 0x9f, 0x9d, 0x96, 0xca, 0x17, 0x3a, + 0xee, 0x3e, 0x3c, 0xbc, 0xaf, 0x08, 0xbb, 0xc1, 0x36, 0x43, 0x7c, 0x1f, 0xe2, 0x33, 0xe7, 0x41, + 0xee, 0xb0, 0x0f, 0xc1, 0xfe, 0x99, 0xcb, 0xfe, 0xbb, 0x10, 0x7d, 0xfc, 0xa7, 0x98, 0x4e, 0x3b, + 0x16, 0xfb, 0x9d, 0x68, 0x2f, 0xf4, 0xb4, 0x47, 0x22, 0xef, 0xc2, 0x91, 0xa7, 0x49, 0xdb, 0x61, + 0x9a, 0x14, 0xff, 0x73, 0xe6, 0x48, 0xb0, 0x96, 0x28, 0xf1, 0xff, 0x58, 0x21, 0x16, 0x06, 0x21, + 0x94, 0x8f, 0x27, 0x88, 0xfb, 0x8b, 0x1d, 0xff, 0x95, 0x4d, 0x31, 0xf2, 0x7f, 0x6c, 0x94, 0x08, + 0xa5, 0xfc, 0x0b, 0x12, 0xdc, 0xd5, 0xd2, 0x34, 0x8f, 0xaa, 0x45, 0x80, 0x48, 0x9e, 0x97, 0xfa, + 0xdb, 0xc5, 0x88, 0x90, 0x12, 0x46, 0x2d, 0xc2, 0x3e, 0xd0, 0x55, 0x58, 0x26, 0x45, 0x4c, 0xda, + 0xe7, 0xe1, 0x70, 0x5c, 0x58, 0x61, 0xa6, 0x67, 0x61, 0x34, 0x3e, 0x9f, 0xe1, 0x45, 0xce, 0x01, + 0x56, 0xa3, 0x46, 0x62, 0x73, 0x1a, 0x59, 0x6d, 0xee, 0x9a, 0xc0, 0x3c, 0x15, 0xc8, 0x06, 0xa8, + 0x3c, 0xe3, 0xf4, 0x6c, 0x9d, 0x90, 0x52, 0xfe, 0xaa, 0x04, 0x33, 0xf1, 0x16, 0xc2, 0x61, 0xc1, + 0x7b, 0xdd, 0xf5, 0xbb, 0x63, 0x8e, 0xf4, 0x5d, 0x09, 0xee, 0xd9, 0x47, 0x0d, 0x6e, 0xb3, 0x9b, + 0x30, 0x19, 0x19, 0x6f, 0xc4, 0x8d, 0x17, 0xe1, 0x5c, 0x27, 0xbb, 0x0f, 0x94, 0x41, 0x7a, 0x3d, + 0x46, 0xec, 0xf8, 0xa5, 0x6f, 0x4d, 0x4f, 0xb4, 0x7e, 0xf3, 0x94, 0x89, 0xd6, 0x31, 0xe2, 0x0e, + 0x7a, 0xe1, 0xef, 0x4a, 0xf0, 0x60, 0x5c, 0xd5, 0x36, 0xb3, 0xd2, 0x37, 0x51, 0xd7, 0xfd, 0x7b, + 0x09, 0x4e, 0xf6, 0xa2, 0x0f, 0xef, 0xc3, 0x2d, 0x98, 0x08, 0x0b, 0xc5, 0xe6, 0x2e, 0x7c, 0xa8, + 0x8f, 0xe9, 0x3e, 0x8f, 0x05, 0x14, 0x70, 0x7b, 0x1d, 0xfa, 0xea, 0x5f, 0x4a, 0x3c, 0x7e, 0xa3, + 0x6e, 0x12, 0x74, 0x4c, 0x7c, 0xe2, 0xd3, 0x67, 0xc7, 0x44, 0x26, 0x3f, 0x23, 0xb1, 0xc9, 0x4f, + 0x9b, 0x2e, 0x4f, 0xdc, 0xa1, 0x6c, 0x74, 0x9d, 0x67, 0xeb, 0x36, 0x95, 0xe7, 0x7b, 0x61, 0xa2, + 0x4d, 0x68, 0xf1, 0xc4, 0xd4, 0x47, 0x64, 0x29, 0xa8, 0x35, 0x78, 0xe4, 0x7f, 0x23, 0xc1, 0x34, + 0x6d, 0xb8, 0x4d, 0x37, 0xbe, 0x99, 0xed, 0x59, 0xe7, 0xb9, 0xb7, 0xad, 0x5a, 0xdc, 0xb0, 0x4b, + 0x30, 0xc0, 0x3c, 0x94, 0xdb, 0xf2, 0x00, 0x2e, 0xce, 0x19, 0x84, 0xb9, 0x7e, 0x41, 0xe8, 0xd7, + 0x3e, 0x61, 0xbc, 0x4e, 0x76, 0xbc, 0x53, 0x09, 0xe3, 0x1b, 0x22, 0xd7, 0xb7, 0x57, 0x83, 0xdb, + 0x4d, 0xbf, 0x63, 0xb9, 0x9e, 0x19, 0xf1, 0x0d, 0x4a, 0xea, 0x81, 0x4e, 0x5d, 0x92, 0xfa, 0x0f, + 0x79, 0x1f, 0x05, 0x49, 0xbd, 0x8b, 0x3e, 0x6f, 0xc6, 0xa4, 0xfe, 0x27, 0x09, 0x38, 0x4a, 0x75, + 0x8b, 0xce, 0xbe, 0xde, 0x80, 0xbe, 0x51, 0x01, 0x79, 0xae, 0xae, 0xde, 0xa9, 0x5c, 0x94, 0xf3, + 0x5c, 0xfd, 0x6a, 0x6c, 0x44, 0x57, 0x01, 0x55, 0x3d, 0xbf, 0xb9, 0x81, 0xe4, 0x81, 0x1b, 0xa8, + 0x7a, 0xfe, 0xd5, 0x7d, 0x4a, 0x86, 0xd4, 0x81, 0xbd, 0xeb, 0xeb, 0x12, 0x14, 0xda, 0xf5, 0x00, + 0xf7, 0x26, 0x03, 0x8e, 0xc4, 0x16, 0x16, 0x9a, 0x1d, 0xea, 0xe1, 0x5e, 0xa6, 0xd3, 0x4d, 0xe1, + 0x7f, 0xd8, 0xc5, 0xaf, 0x6b, 0x02, 0xf8, 0x67, 0x62, 0x88, 0x0b, 0x02, 0xa6, 0x75, 0x36, 0xf6, + 0xc3, 0x1f, 0xf6, 0xbf, 0xd2, 0x32, 0xc2, 0xbc, 0x29, 0x26, 0x76, 0xdf, 0x94, 0x60, 0xaa, 0x83, + 0xd8, 0x6f, 0xe6, 0xf2, 0x62, 0xa7, 0xa3, 0x4b, 0xdd, 0xe9, 0x59, 0xe4, 0x69, 0x1e, 0x8f, 0xf1, + 0xc3, 0x8b, 0x91, 0x55, 0x84, 0x76, 0xb7, 0x62, 0xe4, 0x77, 0xc3, 0xb1, 0xb6, 0x54, 0x5c, 0xb6, + 0x12, 0xa4, 0x76, 0x0c, 0xcf, 0xe7, 0x62, 0xdd, 0xdf, 0x49, 0xac, 0x26, 0x6a, 0x4a, 0x23, 0x23, + 0xc8, 0x51, 0xd6, 0xeb, 0xb6, 0x6d, 0x72, 0x31, 0xe4, 0xcb, 0x30, 0x1e, 0x81, 0xf1, 0x46, 0xce, + 0x40, 0xca, 0xb1, 0xf9, 0x45, 0xd3, 0xa1, 0x53, 0xc7, 0x3b, 0x35, 0x42, 0x68, 0xb8, 0xda, 0x14, + 0x5f, 0x9e, 0x04, 0xc4, 0x98, 0xd1, 0xd5, 0x6f, 0xd1, 0xc4, 0x06, 0x4c, 0xc4, 0xa0, 0xbc, 0x91, + 0xb7, 0xc3, 0x80, 0x43, 0x21, 0xbc, 0x99, 0x8e, 0xc7, 0x26, 0x18, 0x9d, 0x28, 0xdb, 0x18, 0xcd, + 0xa9, 0xef, 0x1d, 0x86, 0x34, 0xe5, 0x8a, 0x3e, 0x29, 0x01, 0x44, 0xd6, 0xb2, 0x8b, 0x9d, 0xd8, + 0xb4, 0x5f, 0xcd, 0x29, 0xcc, 0xf6, 0x8c, 0xcf, 0xeb, 0xee, 0x93, 0x3f, 0xfe, 0xaf, 0xbf, 0xf3, + 0x33, 0x89, 0xfb, 0x90, 0x3c, 0xdb, 0x61, 0x1d, 0x29, 0x12, 0x8c, 0x5f, 0x94, 0xa2, 0xa7, 0xeb, + 0x1e, 0xe9, 0xad, 0x29, 0x21, 0x59, 0xb1, 0x57, 0x74, 0x2e, 0xd8, 0x79, 0x2a, 0xd8, 0x13, 0xe8, + 0xf1, 0xee, 0x82, 0xcd, 0xbe, 0x2f, 0x1e, 0x5d, 0x1f, 0x40, 0xdf, 0x94, 0x60, 0xb2, 0xdd, 0x32, + 0x01, 0x3a, 0xd7, 0x9b, 0x14, 0xad, 0x05, 0x59, 0xe1, 0xc9, 0x03, 0x50, 0x72, 0x55, 0x16, 0xa9, + 0x2a, 0x73, 0xe8, 0xa9, 0x03, 0xa8, 0x32, 0x1b, 0x19, 0xfd, 0xd0, 0xff, 0x93, 0xe0, 0xee, 0x7d, + 0xa7, 0xd0, 0x68, 0xae, 0x37, 0x29, 0xf7, 0xa9, 0x3c, 0x0b, 0xe5, 0xd7, 0xc2, 0x82, 0x6b, 0xfc, + 0x34, 0xd5, 0xf8, 0x32, 0x5a, 0x3a, 0x88, 0xc6, 0x61, 0x99, 0x18, 0xd5, 0xfd, 0xb7, 0xa5, 0xd8, + 0x01, 0x93, 0xfd, 0xdd, 0xa9, 0x65, 0xee, 0xd8, 0x25, 0x30, 0x5a, 0xa7, 0x04, 0xf2, 0xb3, 0x54, + 0x05, 0x05, 0xad, 0xbf, 0xc6, 0x4e, 0x9b, 0x7d, 0x5f, 0x7c, 0x50, 0xf9, 0x00, 0xfa, 0x3f, 0x52, + 0xfb, 0x13, 0x1d, 0x67, 0xf7, 0x15, 0xb1, 0xf3, 0xbc, 0xb8, 0x70, 0xae, 0x7f, 0x42, 0xae, 0x64, + 0x9d, 0x2a, 0x59, 0x43, 0xf8, 0x4e, 0x2b, 0xd9, 0xb6, 0x13, 0xd1, 0xef, 0x48, 0x30, 0xd9, 0x6e, + 0x46, 0xd7, 0x25, 0x2c, 0xf7, 0x99, 0xcb, 0x76, 0x09, 0xcb, 0xfd, 0xa6, 0x8f, 0xf2, 0xdb, 0xa9, + 0xf2, 0x67, 0xd0, 0xe9, 0x4e, 0xca, 0xef, 0xdb, 0x8b, 0x24, 0x16, 0xf7, 0x9d, 0xf9, 0x74, 0x89, + 0xc5, 0x5e, 0x66, 0x81, 0x5d, 0x62, 0xb1, 0xa7, 0x89, 0x57, 0xf7, 0x58, 0x0c, 0x34, 0xeb, 0xb1, + 0x1b, 0x3d, 0xf4, 0x1b, 0x12, 0x8c, 0xc4, 0xea, 0x72, 0xf4, 0xd8, 0xbe, 0x82, 0xb6, 0x9b, 0x45, + 0x15, 0x4e, 0xf5, 0x43, 0xc2, 0x75, 0x59, 0xa2, 0xba, 0xcc, 0xa3, 0xb9, 0x83, 0xe8, 0xe2, 0xc6, + 0x24, 0xfe, 0xba, 0x04, 0x13, 0x6d, 0x4a, 0xd8, 0x2e, 0x51, 0xd8, 0xb9, 0x74, 0x2f, 0x9c, 0xeb, + 0x9f, 0x90, 0x6b, 0x75, 0x81, 0x6a, 0xf5, 0x2e, 0xf4, 0xce, 0x83, 0x68, 0x15, 0x19, 0x9f, 0x6f, + 0x85, 0x3b, 0xc6, 0x91, 0x76, 0xd0, 0x99, 0x3e, 0x05, 0x13, 0x0a, 0x9d, 0xed, 0x9b, 0x8e, 0xeb, + 0xf3, 0x0c, 0xd5, 0xe7, 0x69, 0xb4, 0xf6, 0xda, 0xf4, 0x69, 0x1d, 0xd6, 0xbf, 0xdc, 0x7a, 0x79, + 0x66, 0x7f, 0x2f, 0x6a, 0x5b, 0xac, 0x16, 0x1e, 0xef, 0x8b, 0x86, 0x2b, 0x75, 0x8e, 0x2a, 0x75, + 0x0a, 0x3d, 0xda, 0x49, 0xa9, 0xc8, 0xb1, 0x00, 0xc3, 0xda, 0xb6, 0x67, 0xdf, 0xc7, 0x4a, 0xe0, + 0x0f, 0xa0, 0x1f, 0x13, 0x5b, 0xb2, 0x27, 0xf6, 0x6d, 0x37, 0x52, 0xc7, 0x16, 0x1e, 0xec, 0x01, + 0x93, 0xcb, 0x75, 0x1f, 0x95, 0x6b, 0x0a, 0x1d, 0xef, 0x24, 0x17, 0xa9, 0x65, 0xd1, 0x47, 0xa5, + 0xe0, 0x14, 0xc7, 0xc9, 0xfd, 0x79, 0x47, 0x8b, 0xdd, 0xc2, 0x43, 0x3d, 0xe1, 0x72, 0x49, 0xee, + 0xa7, 0x92, 0xcc, 0xa0, 0xa9, 0x8e, 0x92, 0xb0, 0xd2, 0xf7, 0x4e, 0x6f, 0xd0, 0x7e, 0x62, 0x02, + 0xa6, 0x3b, 0xb4, 0xe8, 0xef, 0x1e, 0xe8, 0x8e, 0x58, 0x97, 0x4b, 0x5c, 0x3d, 0xee, 0xb9, 0xbe, + 0x9a, 0x02, 0xb4, 0xe2, 0xd5, 0xe6, 0x5d, 0xcc, 0xfe, 0x61, 0x10, 0x0f, 0xc7, 0xa6, 0x3b, 0x0b, + 0xd2, 0x6b, 0xba, 0xb3, 0xb0, 0x12, 0xbb, 0x05, 0x90, 0xe8, 0xef, 0xee, 0x51, 0xcf, 0x57, 0x01, + 0x92, 0x6f, 0xc8, 0x55, 0x80, 0xf6, 0x67, 0xc9, 0x52, 0x3f, 0xc0, 0x23, 0xad, 0xe9, 0x37, 0xe6, + 0x48, 0xeb, 0x11, 0x18, 0xe0, 0x97, 0x84, 0xd8, 0xff, 0x65, 0xe7, 0x6f, 0xe8, 0x09, 0xf1, 0xef, + 0xac, 0x07, 0x7b, 0x3b, 0x9e, 0xc3, 0xb0, 0xf9, 0x41, 0x90, 0xaf, 0x24, 0x21, 0xb7, 0xe2, 0xd5, + 0x2a, 0x55, 0xc3, 0x7f, 0x9d, 0x7c, 0xcf, 0xe9, 0x7c, 0x0a, 0x78, 0xfe, 0xf6, 0xad, 0xe9, 0x51, + 0x66, 0xb2, 0x3b, 0x69, 0xa8, 0x3a, 0x8c, 0x35, 0xdd, 0xb7, 0xe3, 0xae, 0xb9, 0x70, 0x90, 0x6b, + 0x7f, 0x4d, 0xac, 0x64, 0x7a, 0x70, 0x33, 0x12, 0x20, 0x68, 0xb7, 0x7d, 0x34, 0xb0, 0x93, 0x46, + 0x17, 0x5f, 0xcf, 0x4b, 0x31, 0xac, 0x0b, 0xbf, 0x9a, 0x80, 0xa1, 0x15, 0x4f, 0x14, 0x75, 0xf8, + 0xcf, 0xec, 0x91, 0xef, 0xb3, 0xc1, 0xc5, 0xe6, 0x64, 0x6f, 0x81, 0x10, 0xbf, 0xec, 0xfc, 0xad, + 0x24, 0xcd, 0xc3, 0x65, 0x5c, 0x33, 0xac, 0xa0, 0xac, 0xc4, 0x6f, 0x9d, 0x5c, 0xfd, 0x21, 0x3a, + 0xb9, 0x1a, 0xf6, 0x70, 0xea, 0x20, 0x3d, 0xfc, 0x5b, 0x09, 0x18, 0x59, 0xf1, 0x6a, 0x57, 0xac, + 0xea, 0x5b, 0xa1, 0xf2, 0x5a, 0x42, 0xe5, 0x8e, 0x97, 0x66, 0x9f, 0xca, 0x74, 0xbc, 0xc3, 0x5f, + 0xc3, 0x16, 0xf6, 0x0c, 0xef, 0x40, 0xf5, 0x59, 0x6f, 0xf5, 0xd7, 0x37, 0xd3, 0x30, 0xbc, 0xc8, + 0x5a, 0xd9, 0xf0, 0x89, 0x53, 0xbc, 0xa6, 0x35, 0x5a, 0xe4, 0xf1, 0x1f, 0x3f, 0xa3, 0xbf, 0x7f, + 0xa7, 0x3a, 0xf6, 0x0d, 0x2c, 0x96, 0xf1, 0x97, 0xfa, 0x2e, 0x8c, 0xf8, 0x65, 0xd2, 0x66, 0x7e, + 0x32, 0xfb, 0x1d, 0xb5, 0x4d, 0x02, 0x59, 0x27, 0x00, 0xf4, 0x21, 0x09, 0x0e, 0x53, 0xac, 0xd0, + 0x5d, 0x28, 0xa6, 0xb8, 0xfc, 0xd2, 0xb1, 0x98, 0x5f, 0xd6, 0x22, 0x3b, 0x73, 0x94, 0x57, 0xf9, + 0x3e, 0x7e, 0x16, 0xfb, 0x78, 0xa4, 0xf1, 0x66, 0xb6, 0xb2, 0x32, 0x61, 0xb6, 0x50, 0x7a, 0x4d, + 0xfb, 0x39, 0xa9, 0x83, 0xef, 0xe7, 0x5c, 0x22, 0x05, 0x48, 0x30, 0x09, 0xcf, 0xa7, 0xbb, 0xdc, + 0x37, 0x6b, 0xde, 0xf4, 0x8d, 0x12, 0xa3, 0x8f, 0x48, 0x70, 0xb8, 0xed, 0xfa, 0x04, 0xfd, 0x07, + 0x92, 0x7d, 0x6e, 0x2a, 0x37, 0x19, 0xa7, 0x2d, 0x5f, 0x59, 0x99, 0x6c, 0xb4, 0x5b, 0xe8, 0x59, + 0x87, 0x91, 0xd8, 0xda, 0x42, 0x5e, 0xfc, 0x1b, 0xd8, 0xde, 0x4f, 0x07, 0xc7, 0x19, 0xa0, 0x02, + 0x64, 0xf0, 0xae, 0x63, 0xbb, 0x3e, 0xae, 0xd2, 0x2b, 0xc8, 0x19, 0x25, 0x78, 0x97, 0x6f, 0x00, + 0x6a, 0xed, 0x5c, 0x74, 0x19, 0x06, 0xe3, 0x69, 0xee, 0x00, 0x7b, 0x4b, 0x82, 0x03, 0x9a, 0x84, + 0x74, 0xe8, 0xdf, 0x49, 0x85, 0xbd, 0xdc, 0xe9, 0xe4, 0xf0, 0xa7, 0x01, 0x00, 0x00, 0xff, 0xff, + 0x36, 0x66, 0xc7, 0xfd, 0x47, 0x91, 0x00, 0x00, } r := bytes.NewReader(gzipped) gzipr, err := compress_gzip.NewReader(r) From e7ee599a60b489b435d27d70f0354c99df974985 Mon Sep 17 00:00:00 2001 From: anilCSE Date: Fri, 21 Aug 2020 00:39:31 +0530 Subject: [PATCH 06/27] Add swagger mixer command --- scripts/protocgen.sh | 2 ++ 1 file changed, 2 insertions(+) diff --git a/scripts/protocgen.sh b/scripts/protocgen.sh index bd53db1113d3..937ca9f238ac 100755 --- a/scripts/protocgen.sh +++ b/scripts/protocgen.sh @@ -43,3 +43,5 @@ cp -r ibc/* ./x/ibc/ rm -rf github.com rm -rf cosmos rm -rf ibc + +swagger mixin ./x/auth/**/query.swagger.json ./x/**/**/*swagger.json \ No newline at end of file From 4108303f8d9210d3ffcd9cbc75befc7a938e5349 Mon Sep 17 00:00:00 2001 From: anilCSE Date: Sat, 22 Aug 2020 00:25:32 +0530 Subject: [PATCH 07/27] add swagger options --- contrib/devtools/Makefile | 12 +++++------- scripts/go-swagger.sh | 4 ++++ scripts/protocgen.sh | 2 +- 3 files changed, 10 insertions(+), 8 deletions(-) create mode 100644 scripts/go-swagger.sh diff --git a/contrib/devtools/Makefile b/contrib/devtools/Makefile index a89e75512758..a54f84bcda7b 100644 --- a/contrib/devtools/Makefile +++ b/contrib/devtools/Makefile @@ -85,7 +85,7 @@ ifeq ($(UNAME_S),Darwin) PROTOC_ZIP ?= protoc-3.11.2-osx-x86_64.zip endif -proto-tools: proto-tools-stamp buf +proto-tools: proto-tools-stamp go-swagger buf proto-tools-stamp: @echo "Installing protoc compiler..." @@ -101,14 +101,12 @@ proto-tools-stamp: @echo "Installing protoc-gen-grpc-gateway..." @go install github.com/grpc-ecosystem/grpc-gateway/protoc-gen-grpc-gateway - @echo "Installing go-swagger..." - @(download_url=$(curl -s https://api.github.com/repos/go-swagger/go-swagger/releases/latest | \ - jq -r '.assets[] | select(.name | contains("'"$(uname | tr '[:upper:]' '[:lower:]')"'_amd64")) | .browser_download_url') \ - curl -o /usr/local/bin/swagger -L'#' "$download_url" \ - chmod +x /usr/local/bin/swagger) - touch $@ +go-swagger: + @echo "Installing go-swagger..." + @./scripts/go-swagger.sh + buf: buf-stamp buf-stamp: diff --git a/scripts/go-swagger.sh b/scripts/go-swagger.sh new file mode 100644 index 000000000000..ff6aa59ed016 --- /dev/null +++ b/scripts/go-swagger.sh @@ -0,0 +1,4 @@ +download_url=$(curl -s https://api.github.com/repos/go-swagger/go-swagger/releases/latest | \ + jq -r '.assets[] | select(.name | contains("'"$(uname | tr '[:upper:]' '[:lower:]')"'_amd64")) | .browser_download_url') +curl -o /usr/local/bin/swagger -L'#' "$download_url" +chmod +x /usr/local/bin/swagger \ No newline at end of file diff --git a/scripts/protocgen.sh b/scripts/protocgen.sh index 937ca9f238ac..0f2099dade72 100755 --- a/scripts/protocgen.sh +++ b/scripts/protocgen.sh @@ -26,7 +26,7 @@ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. \ -I "proto" \ -I "third_party/proto" \ "$query_file" \ - --swagger_out=logtostderr=true:. + --swagger_out=logtostderr=true,fqn_for_swagger_name=true,allow_merge=true,merge_file_name=apidoc:. fi proto_files=${proto_files}" ${dir:2}/*.proto" From c1ce287a6453d1bcb1b4277b5a8b850630198cb9 Mon Sep 17 00:00:00 2001 From: anilCSE Date: Sat, 22 Aug 2020 01:09:29 +0530 Subject: [PATCH 08/27] remove files --- scripts/protocgen.sh | 34 +- x/auth/v1beta1/query.swagger.json | 155 --- x/bank/v1beta1/query.swagger.json | 377 ------ x/distribution/v1beta1/query.swagger.json | 628 ---------- x/evidence/v1beta1/query.swagger.json | 214 ---- x/gov/v1beta1/query.swagger.json | 785 ------------ x/ibc/channel/query.swagger.json | 982 --------------- x/ibc/connection/query.swagger.json | 520 -------- x/ibc/transfer/query.swagger.json | 273 ---- x/mint/v1beta1/query.swagger.json | 182 --- x/params/v1beta1/query.swagger.json | 114 -- x/slashing/v1beta1/query.swagger.json | 302 ----- x/staking/v1beta1/query.swagger.json | 1385 --------------------- x/upgrade/v1beta1/query.swagger.json | 150 --- 14 files changed, 24 insertions(+), 6077 deletions(-) delete mode 100644 x/auth/v1beta1/query.swagger.json delete mode 100644 x/bank/v1beta1/query.swagger.json delete mode 100644 x/distribution/v1beta1/query.swagger.json delete mode 100644 x/evidence/v1beta1/query.swagger.json delete mode 100644 x/gov/v1beta1/query.swagger.json delete mode 100644 x/ibc/channel/query.swagger.json delete mode 100644 x/ibc/connection/query.swagger.json delete mode 100644 x/ibc/transfer/query.swagger.json delete mode 100644 x/mint/v1beta1/query.swagger.json delete mode 100644 x/params/v1beta1/query.swagger.json delete mode 100644 x/slashing/v1beta1/query.swagger.json delete mode 100644 x/staking/v1beta1/query.swagger.json delete mode 100644 x/upgrade/v1beta1/query.swagger.json diff --git a/scripts/protocgen.sh b/scripts/protocgen.sh index 0f2099dade72..08472ff11000 100755 --- a/scripts/protocgen.sh +++ b/scripts/protocgen.sh @@ -3,6 +3,7 @@ set -eo pipefail proto_files='' +query_files='' proto_dirs=$(find ./proto -path -prune -o -name '*.proto' -print0 | xargs -0 -n1 dirname | sort | uniq) for dir in $proto_dirs; do @@ -22,26 +23,39 @@ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. \ query_file=$(find "${dir}" -maxdepth 1 -name 'query.proto') if [[ ! -z "$query_file" ]]; then - protoc \ - -I "proto" \ - -I "third_party/proto" \ - "$query_file" \ - --swagger_out=logtostderr=true,fqn_for_swagger_name=true,allow_merge=true,merge_file_name=apidoc:. + query_files=${query_files}" ${query_file}" +# protoc \ +# -I "proto" \ +# -I "third_party/proto" \ +# "$query_file" \ +# --go_out=plugins=grpc:pkg \ +# --swagger_out=logtostderr=true,fqn_for_swagger_name=true:. fi + + proto_files=${proto_files}" ${dir:2}/*.proto" done +protoc \ + -I "proto" \ + -I "third_party/proto" \ + --swagger_out=logtostderr=true,fqn_for_swagger_name=true:. \ + --go_out=plugins=grpc:pkg $(find ./ -name 'query.proto') + +#echo $query_files +#protoc \ +#-I "proto" \ +#-I "third_party/proto" \ +#$query_files \ +#--swagger_out=logtostderr=true,include_package_in_tags=true,fqn_for_swagger_name=true,allow_merge=true:. + # generate codec/testdata proto code protoc -I "proto" -I "third_party/proto" -I "testutil/testdata" --gocosmos_out=plugins=interfacetype+grpc,\ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. ./testutil/testdata/proto.proto # move proto files to the right places cp -r github.com/cosmos/cosmos-sdk/* ./ -cp -r cosmos/* ./x/ -cp -r ibc/* ./x/ibc/ rm -rf github.com -rm -rf cosmos -rm -rf ibc -swagger mixin ./x/auth/**/query.swagger.json ./x/**/**/*swagger.json \ No newline at end of file +#swagger mixin ./x/auth/**/query.swagger.json ./x/**/**/*swagger.json \ No newline at end of file diff --git a/x/auth/v1beta1/query.swagger.json b/x/auth/v1beta1/query.swagger.json deleted file mode 100644 index 3c80da300bfe..000000000000 --- a/x/auth/v1beta1/query.swagger.json +++ /dev/null @@ -1,155 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "cosmos/auth/v1beta1/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/cosmos/auth/v1beta1/accounts/{address}": { - "get": { - "summary": "Account returns account details based on address.", - "operationId": "Query_Account", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryAccountResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "address", - "description": "address defines the address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/auth/v1beta1/params": { - "get": { - "summary": "Params queries all parameters.", - "operationId": "Query_Params", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryParamsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "protobufAny": { - "type": "object", - "properties": { - "type_url": { - "type": "string", - "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." - }, - "value": { - "type": "string", - "format": "byte", - "description": "Must be a valid serialized protocol buffer of the above specified type." - } - }, - "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := \u0026pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" - }, - "runtimeError": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/protobufAny" - } - } - } - }, - "v1beta1Params": { - "type": "object", - "properties": { - "max_memo_characters": { - "type": "string", - "format": "uint64" - }, - "tx_sig_limit": { - "type": "string", - "format": "uint64" - }, - "tx_size_cost_per_byte": { - "type": "string", - "format": "uint64" - }, - "sig_verify_cost_ed25519": { - "type": "string", - "format": "uint64" - }, - "sig_verify_cost_secp256k1": { - "type": "string", - "format": "uint64" - } - }, - "description": "Params defines the parameters for the auth module." - }, - "v1beta1QueryAccountResponse": { - "type": "object", - "properties": { - "account": { - "$ref": "#/definitions/protobufAny", - "description": "account defines the account of the corresponding address." - } - }, - "description": "QueryAccountResponse is the response type for the Query/Account RPC method." - }, - "v1beta1QueryParamsResponse": { - "type": "object", - "properties": { - "params": { - "$ref": "#/definitions/v1beta1Params", - "description": "params defines the parameters of the module." - } - }, - "description": "QueryParamsResponse is the response type for the Query/Params RPC method." - } - } -} diff --git a/x/bank/v1beta1/query.swagger.json b/x/bank/v1beta1/query.swagger.json deleted file mode 100644 index 904f88d9b2ed..000000000000 --- a/x/bank/v1beta1/query.swagger.json +++ /dev/null @@ -1,377 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "cosmos/bank/v1beta1/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/cosmos/bank/v1beta1/balances/{address}": { - "get": { - "summary": "AllBalances queries the balance of all coins for a single account.", - "operationId": "Query_AllBalances", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryAllBalancesResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "address", - "description": "address is the address to query balances for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/bank/v1beta1/balances/{address}/{denom}": { - "get": { - "summary": "Balance queries the balance of a single coin for a single account.", - "operationId": "Query_Balance", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryBalanceResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "address", - "description": "address is the address to query balances for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "denom", - "description": "denom is the coin denom to query balances for.", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/bank/v1beta1/params": { - "get": { - "summary": "Params queries the parameters of x/bank module.", - "operationId": "Query_Params", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryParamsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "tags": [ - "Query" - ] - } - }, - "/cosmos/bank/v1beta1/supply": { - "get": { - "summary": "TotalSupply queries the total supply of all coins.", - "operationId": "Query_TotalSupply", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryTotalSupplyResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "tags": [ - "Query" - ] - } - }, - "/cosmos/bank/v1beta1/supply/{denom}": { - "get": { - "summary": "SupplyOf queries the supply of a single coin.", - "operationId": "Query_SupplyOf", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QuerySupplyOfResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "denom", - "description": "denom is the coin denom to query balances for.", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "protobufAny": { - "type": "object", - "properties": { - "type_url": { - "type": "string" - }, - "value": { - "type": "string", - "format": "byte" - } - } - }, - "runtimeError": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/protobufAny" - } - } - } - }, - "v1beta1Coin": { - "type": "object", - "properties": { - "denom": { - "type": "string" - }, - "amount": { - "type": "string" - } - }, - "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." - }, - "v1beta1PageRequest": { - "type": "object", - "properties": { - "key": { - "type": "string", - "format": "byte", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." - }, - "offset": { - "type": "string", - "format": "uint64", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." - }, - "limit": { - "type": "string", - "format": "uint64", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." - }, - "count_total": { - "type": "boolean", - "format": "boolean", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." - } - }, - "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", - "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" - }, - "v1beta1PageResponse": { - "type": "object", - "properties": { - "next_key": { - "type": "string", - "format": "byte", - "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" - }, - "total": { - "type": "string", - "format": "uint64", - "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" - } - }, - "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" - }, - "v1beta1Params": { - "type": "object", - "properties": { - "send_enabled": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1SendEnabled" - } - }, - "default_send_enabled": { - "type": "boolean", - "format": "boolean" - } - }, - "description": "Params defines the set of bank parameters." - }, - "v1beta1QueryAllBalancesResponse": { - "type": "object", - "properties": { - "balances": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1Coin" - }, - "description": "balances is the balances of all the coins." - }, - "pagination": { - "$ref": "#/definitions/v1beta1PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryAllBalancesResponse is the response type for the Query/AllBalances RPC method." - }, - "v1beta1QueryBalanceResponse": { - "type": "object", - "properties": { - "balance": { - "$ref": "#/definitions/v1beta1Coin", - "description": "balance is the balance of the coin." - } - }, - "description": "QueryBalanceResponse is the response type for the Query/Balance RPC method." - }, - "v1beta1QueryParamsResponse": { - "type": "object", - "properties": { - "params": { - "$ref": "#/definitions/v1beta1Params" - } - }, - "description": "QueryParamsResponse defines the response type for querying x/bank parameters." - }, - "v1beta1QuerySupplyOfResponse": { - "type": "object", - "properties": { - "amount": { - "$ref": "#/definitions/v1beta1Coin", - "description": "amount is the supply of the coin." - } - }, - "description": "QuerySupplyOfResponse is the response type for the Query/SupplyOf RPC method." - }, - "v1beta1QueryTotalSupplyResponse": { - "type": "object", - "properties": { - "supply": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1Coin" - }, - "title": "supply is the supply of the coins" - } - }, - "title": "QueryTotalSupplyResponse is the response type for the Query/TotalSupply RPC method" - }, - "v1beta1SendEnabled": { - "type": "object", - "properties": { - "denom": { - "type": "string" - }, - "enabled": { - "type": "boolean", - "format": "boolean" - } - }, - "title": "Send enabled configuration properties for each denomination" - } - } -} diff --git a/x/distribution/v1beta1/query.swagger.json b/x/distribution/v1beta1/query.swagger.json deleted file mode 100644 index b12a15e567f6..000000000000 --- a/x/distribution/v1beta1/query.swagger.json +++ /dev/null @@ -1,628 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "cosmos/distribution/v1beta1/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/cosmos/distribution/v1beta1/community_pool": { - "get": { - "summary": "CommunityPool queries the community pool coins.", - "operationId": "Query_CommunityPool", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryCommunityPoolResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "tags": [ - "Query" - ] - } - }, - "/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards": { - "get": { - "summary": "DelegationTotalRewards queries the total rewards accrued by a each validator.", - "operationId": "Query_DelegationTotalRewards", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryDelegationTotalRewardsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "delegator_address", - "description": "delegator_address defines the delegator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards/{validator_address}": { - "get": { - "summary": "DelegationRewards queries the total rewards accrued by a delegation.", - "operationId": "Query_DelegationRewards", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryDelegationRewardsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "delegator_address", - "description": "delegator_address defines the delegator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "validator_address", - "description": "validator_address defines the validator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/distribution/v1beta1/delegators/{delegator_address}/validators": { - "get": { - "summary": "DelegatorValidators queries the validators of a delegator.", - "operationId": "Query_DelegatorValidators", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryDelegatorValidatorsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "delegator_address", - "description": "delegator_address defines the delegator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/distribution/v1beta1/delegators/{delegator_address}/withdraw_address": { - "get": { - "summary": "DelegatorWithdrawAddress queries withdraw address of a delegator.", - "operationId": "Query_DelegatorWithdrawAddress", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryDelegatorWithdrawAddressResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "delegator_address", - "description": "delegator_address defines the delegator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/distribution/v1beta1/params": { - "get": { - "summary": "Params queries params of the distribution module.", - "operationId": "Query_Params", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryParamsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "tags": [ - "Query" - ] - } - }, - "/cosmos/distribution/v1beta1/validators/{validator_address}/commission": { - "get": { - "summary": "ValidatorCommission queries accumulated commission for a validator.", - "operationId": "Query_ValidatorCommission", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryValidatorCommissionResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "validator_address", - "description": "validator_address defines the validator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/distribution/v1beta1/validators/{validator_address}/outstanding_rewards": { - "get": { - "summary": "ValidatorOutstandingRewards queries rewards of a validator address.", - "operationId": "Query_ValidatorOutstandingRewards", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryValidatorOutstandingRewardsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "validator_address", - "description": "validator_address defines the validator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/distribution/v1beta1/validators/{validator_address}/slashes": { - "get": { - "summary": "ValidatorSlashes queries slash events of a validator.", - "operationId": "Query_ValidatorSlashes", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryValidatorSlashesResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "validator_address", - "description": "validator_address defines the validator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "starting_height", - "description": "starting_height defines the optional starting height to query the slashes.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "ending_height", - "description": "starting_height defines the optional ending height to query the slashes.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "protobufAny": { - "type": "object", - "properties": { - "type_url": { - "type": "string" - }, - "value": { - "type": "string", - "format": "byte" - } - } - }, - "runtimeError": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/protobufAny" - } - } - } - }, - "v1beta1DecCoin": { - "type": "object", - "properties": { - "denom": { - "type": "string" - }, - "amount": { - "type": "string" - } - }, - "description": "DecCoin defines a token with a denomination and a decimal amount.\n\nNOTE: The amount field is an Dec which implements the custom method\nsignatures required by gogoproto." - }, - "v1beta1DelegationDelegatorReward": { - "type": "object", - "properties": { - "validator_address": { - "type": "string", - "format": "byte" - }, - "reward": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1DecCoin" - } - } - }, - "description": "DelegationDelegatorReward defines the properties\nof a delegator's delegation reward." - }, - "v1beta1PageRequest": { - "type": "object", - "properties": { - "key": { - "type": "string", - "format": "byte", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." - }, - "offset": { - "type": "string", - "format": "uint64", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." - }, - "limit": { - "type": "string", - "format": "uint64", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." - }, - "count_total": { - "type": "boolean", - "format": "boolean", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." - } - }, - "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", - "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" - }, - "v1beta1PageResponse": { - "type": "object", - "properties": { - "next_key": { - "type": "string", - "format": "byte", - "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" - }, - "total": { - "type": "string", - "format": "uint64", - "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" - } - }, - "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" - }, - "v1beta1Params": { - "type": "object", - "properties": { - "community_tax": { - "type": "string" - }, - "base_proposer_reward": { - "type": "string" - }, - "bonus_proposer_reward": { - "type": "string" - }, - "withdraw_addr_enabled": { - "type": "boolean", - "format": "boolean" - } - }, - "description": "Params defines the set of distribution parameters." - }, - "v1beta1QueryCommunityPoolResponse": { - "type": "object", - "properties": { - "pool": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1DecCoin" - }, - "description": "pool defines community pool's coins." - } - }, - "description": "QueryCommunityPoolResponse is the response type for the Query/CommunityPool RPC method." - }, - "v1beta1QueryDelegationRewardsResponse": { - "type": "object", - "properties": { - "rewards": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1DecCoin" - }, - "description": "rewards defines the rewards accrued by a delegation." - } - }, - "description": "QueryDelegationRewardsResponse is the response type for the Query/DelegationRewards RPC method." - }, - "v1beta1QueryDelegationTotalRewardsResponse": { - "type": "object", - "properties": { - "rewards": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1DelegationDelegatorReward" - }, - "description": "rewards defines all the rewards accrued by a delegator." - }, - "total": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1DecCoin" - }, - "description": "total defines the sum of all the rewards." - } - }, - "description": "QueryDelegationTotalRewardsResponse is the response type for the Query/DelegationTotalRewards RPC method." - }, - "v1beta1QueryDelegatorValidatorsResponse": { - "type": "object", - "properties": { - "validators": { - "type": "array", - "items": { - "type": "string", - "format": "byte" - }, - "description": "validators defines the validators a delegator is delegating for." - } - }, - "description": "QueryDelegatorValidatorsResponse is the response type for the Query/DelegatorValidators RPC method." - }, - "v1beta1QueryDelegatorWithdrawAddressResponse": { - "type": "object", - "properties": { - "withdraw_address": { - "type": "string", - "format": "byte", - "description": "withdraw_address defines the delegator address to query for." - } - }, - "description": "QueryDelegatorWithdrawAddressResponse is the response type for the Query/DelegatorWithdrawAddress RPC method." - }, - "v1beta1QueryParamsResponse": { - "type": "object", - "properties": { - "params": { - "$ref": "#/definitions/v1beta1Params", - "description": "params defines the parameters of the module." - } - }, - "description": "QueryParamsResponse is the response type for the Query/Params RPC method." - }, - "v1beta1QueryValidatorCommissionResponse": { - "type": "object", - "properties": { - "commission": { - "$ref": "#/definitions/v1beta1ValidatorAccumulatedCommission", - "description": "commission defines the commision the validator received." - } - }, - "title": "QueryValidatorCommissionResponse is the response type for the Query/ValidatorCommission RPC method" - }, - "v1beta1QueryValidatorOutstandingRewardsResponse": { - "type": "object", - "properties": { - "rewards": { - "$ref": "#/definitions/v1beta1ValidatorOutstandingRewards" - } - }, - "description": "QueryValidatorOutstandingRewardsResponse is the response type for the Query/ValidatorOutstandingRewards RPC method." - }, - "v1beta1QueryValidatorSlashesResponse": { - "type": "object", - "properties": { - "slashes": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1ValidatorSlashEvent" - }, - "description": "slashes defines the slashes the validator received." - }, - "pagination": { - "$ref": "#/definitions/v1beta1PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryValidatorSlashesResponse is the response type for the Query/ValidatorSlashes RPC method." - }, - "v1beta1ValidatorAccumulatedCommission": { - "type": "object", - "properties": { - "commission": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1DecCoin" - } - } - }, - "title": "accumulated commission for a validator\nkept as a running counter, can be withdrawn at any time" - }, - "v1beta1ValidatorOutstandingRewards": { - "type": "object", - "properties": { - "rewards": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1DecCoin" - } - } - }, - "title": "outstanding (un-withdrawn) rewards for a validator\ninexpensive to track, allows simple sanity checks" - }, - "v1beta1ValidatorSlashEvent": { - "type": "object", - "properties": { - "validator_period": { - "type": "string", - "format": "uint64" - }, - "fraction": { - "type": "string" - } - }, - "title": "validator slash event\nheight is implicit within the store key\nneeded to calculate appropriate amounts of staking token\nfor delegations which withdraw after a slash has occurred" - } - } -} diff --git a/x/evidence/v1beta1/query.swagger.json b/x/evidence/v1beta1/query.swagger.json deleted file mode 100644 index 688cdcd1229e..000000000000 --- a/x/evidence/v1beta1/query.swagger.json +++ /dev/null @@ -1,214 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "cosmos/evidence/v1beta1/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/cosmos/evidence/v1beta1/evidence": { - "get": { - "summary": "AllEvidence queries all evidence.", - "operationId": "Query_AllEvidence", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryAllEvidenceResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/evidence/v1beta1/evidence/{evidence_hash}": { - "get": { - "summary": "Evidence queries evidence based on evidence hash.", - "operationId": "Query_Evidence", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryEvidenceResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "evidence_hash", - "description": "evidence_hash defines the hash of the requested evidence.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "protobufAny": { - "type": "object", - "properties": { - "type_url": { - "type": "string", - "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." - }, - "value": { - "type": "string", - "format": "byte", - "description": "Must be a valid serialized protocol buffer of the above specified type." - } - }, - "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := \u0026pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" - }, - "runtimeError": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/protobufAny" - } - } - } - }, - "v1beta1PageRequest": { - "type": "object", - "properties": { - "key": { - "type": "string", - "format": "byte", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." - }, - "offset": { - "type": "string", - "format": "uint64", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." - }, - "limit": { - "type": "string", - "format": "uint64", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." - }, - "count_total": { - "type": "boolean", - "format": "boolean", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." - } - }, - "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", - "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" - }, - "v1beta1PageResponse": { - "type": "object", - "properties": { - "next_key": { - "type": "string", - "format": "byte", - "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" - }, - "total": { - "type": "string", - "format": "uint64", - "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" - } - }, - "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" - }, - "v1beta1QueryAllEvidenceResponse": { - "type": "object", - "properties": { - "evidence": { - "type": "array", - "items": { - "$ref": "#/definitions/protobufAny" - }, - "description": "evidence returns all evidences." - }, - "pagination": { - "$ref": "#/definitions/v1beta1PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryAllEvidenceResponse is the response type for the Query/AllEvidence RPC method." - }, - "v1beta1QueryEvidenceResponse": { - "type": "object", - "properties": { - "evidence": { - "$ref": "#/definitions/protobufAny", - "description": "evidence returns the requested evidence." - } - }, - "description": "QueryEvidenceResponse is the response type for the Query/Evidence RPC method." - } - } -} diff --git a/x/gov/v1beta1/query.swagger.json b/x/gov/v1beta1/query.swagger.json deleted file mode 100644 index a0f66e154ff4..000000000000 --- a/x/gov/v1beta1/query.swagger.json +++ /dev/null @@ -1,785 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "cosmos/gov/v1beta1/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/cosmos/gov/v1beta1/params/{params_type}": { - "get": { - "summary": "Params queries all parameters of the gov module.", - "operationId": "Query_Params", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryParamsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "params_type", - "description": "params_type defines which parameters to query for, can be one of \"voting\", \"tallying\" or \"deposit\".", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/gov/v1beta1/proposals": { - "get": { - "summary": "Proposals queries all proposals based on given status.", - "operationId": "Query_Proposals", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryProposalsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "proposal_status", - "description": "proposal_status defines the status of the proposals.\n\n - PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed.", - "in": "query", - "required": false, - "type": "string", - "enum": [ - "PROPOSAL_STATUS_UNSPECIFIED", - "PROPOSAL_STATUS_DEPOSIT_PERIOD", - "PROPOSAL_STATUS_VOTING_PERIOD", - "PROPOSAL_STATUS_PASSED", - "PROPOSAL_STATUS_REJECTED", - "PROPOSAL_STATUS_FAILED" - ], - "default": "PROPOSAL_STATUS_UNSPECIFIED" - }, - { - "name": "voter", - "description": "voter defines the voter address for the proposals.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "depositor", - "description": "depositor defines the deposit addresses from the proposals.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/gov/v1beta1/proposals/{proposal_id}": { - "get": { - "summary": "Proposal queries proposal details based on ProposalID.", - "operationId": "Query_Proposal", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryProposalResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "proposal_id", - "description": "proposal_id defines the unique id of the proposal.", - "in": "path", - "required": true, - "type": "string", - "format": "uint64" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/gov/v1beta1/proposals/{proposal_id}/deposits": { - "get": { - "summary": "Deposits queries all deposits of a single proposal.", - "operationId": "Query_Deposits", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryDepositsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "proposal_id", - "description": "proposal_id defines the unique id of the proposal.", - "in": "path", - "required": true, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/gov/v1beta1/proposals/{proposal_id}/deposits/{depositor}": { - "get": { - "summary": "Deposit queries single deposit information based proposalID, depositAddr.", - "operationId": "Query_Deposit", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryDepositResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "proposal_id", - "description": "proposal_id defines the unique id of the proposal.", - "in": "path", - "required": true, - "type": "string", - "format": "uint64" - }, - { - "name": "depositor", - "description": "depositor defines the deposit addresses from the proposals.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/gov/v1beta1/proposals/{proposal_id}/tally": { - "get": { - "summary": "TallyResult queries the tally of a proposal vote.", - "operationId": "Query_TallyResult", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryTallyResultResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "proposal_id", - "description": "proposal_id defines the unique id of the proposal.", - "in": "path", - "required": true, - "type": "string", - "format": "uint64" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/gov/v1beta1/proposals/{proposal_id}/votes": { - "get": { - "summary": "Votes queries votes of a given proposal.", - "operationId": "Query_Votes", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryVotesResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "proposal_id", - "description": "proposal_id defines the unique id of the proposal.", - "in": "path", - "required": true, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/gov/v1beta1/proposals/{proposal_id}/votes/{voter}": { - "get": { - "summary": "Vote queries voted information based on proposalID, voterAddr.", - "operationId": "Query_Vote", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryVoteResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "proposal_id", - "description": "proposal_id defines the unique id of the proposal.", - "in": "path", - "required": true, - "type": "string", - "format": "uint64" - }, - { - "name": "voter", - "description": "voter defines the oter address for the proposals.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "protobufAny": { - "type": "object", - "properties": { - "type_url": { - "type": "string", - "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." - }, - "value": { - "type": "string", - "format": "byte", - "description": "Must be a valid serialized protocol buffer of the above specified type." - } - }, - "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := \u0026pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" - }, - "runtimeError": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/protobufAny" - } - } - } - }, - "v1beta1Coin": { - "type": "object", - "properties": { - "denom": { - "type": "string" - }, - "amount": { - "type": "string" - } - }, - "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." - }, - "v1beta1Deposit": { - "type": "object", - "properties": { - "proposal_id": { - "type": "string", - "format": "uint64" - }, - "depositor": { - "type": "string", - "format": "byte" - }, - "amount": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1Coin" - } - } - }, - "title": "Deposit defines an amount deposited by an account address to an active proposal" - }, - "v1beta1DepositParams": { - "type": "object", - "properties": { - "min_deposit": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1Coin" - }, - "description": "Minimum deposit for a proposal to enter voting period." - }, - "max_deposit_period": { - "type": "string", - "description": "Maximum period for Atom holders to deposit on a proposal. Initial value: 2 months." - } - }, - "title": "DepositParams defines the params around deposits for governance" - }, - "v1beta1PageRequest": { - "type": "object", - "properties": { - "key": { - "type": "string", - "format": "byte", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." - }, - "offset": { - "type": "string", - "format": "uint64", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." - }, - "limit": { - "type": "string", - "format": "uint64", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." - }, - "count_total": { - "type": "boolean", - "format": "boolean", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." - } - }, - "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", - "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" - }, - "v1beta1PageResponse": { - "type": "object", - "properties": { - "next_key": { - "type": "string", - "format": "byte", - "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" - }, - "total": { - "type": "string", - "format": "uint64", - "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" - } - }, - "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" - }, - "v1beta1Proposal": { - "type": "object", - "properties": { - "proposal_id": { - "type": "string", - "format": "uint64" - }, - "content": { - "$ref": "#/definitions/protobufAny" - }, - "status": { - "$ref": "#/definitions/v1beta1ProposalStatus" - }, - "final_tally_result": { - "$ref": "#/definitions/v1beta1TallyResult" - }, - "submit_time": { - "type": "string", - "format": "date-time" - }, - "deposit_end_time": { - "type": "string", - "format": "date-time" - }, - "total_deposit": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1Coin" - } - }, - "voting_start_time": { - "type": "string", - "format": "date-time" - }, - "voting_end_time": { - "type": "string", - "format": "date-time" - } - }, - "title": "Proposal defines the core field members of a governance proposal" - }, - "v1beta1ProposalStatus": { - "type": "string", - "enum": [ - "PROPOSAL_STATUS_UNSPECIFIED", - "PROPOSAL_STATUS_DEPOSIT_PERIOD", - "PROPOSAL_STATUS_VOTING_PERIOD", - "PROPOSAL_STATUS_PASSED", - "PROPOSAL_STATUS_REJECTED", - "PROPOSAL_STATUS_FAILED" - ], - "default": "PROPOSAL_STATUS_UNSPECIFIED", - "description": "- PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed.", - "title": "ProposalStatus is a type alias that represents a proposal status as a byte" - }, - "v1beta1QueryDepositResponse": { - "type": "object", - "properties": { - "deposit": { - "$ref": "#/definitions/v1beta1Deposit", - "description": "deposit defines the requested deposit." - } - }, - "description": "QueryDepositResponse is the response type for the Query/Deposit RPC method." - }, - "v1beta1QueryDepositsResponse": { - "type": "object", - "properties": { - "deposits": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1Deposit" - } - }, - "pagination": { - "$ref": "#/definitions/v1beta1PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryDepositsResponse is the response type for the Query/Deposits RPC method." - }, - "v1beta1QueryParamsResponse": { - "type": "object", - "properties": { - "voting_params": { - "$ref": "#/definitions/v1beta1VotingParams", - "description": "voting_params defines the parameters related to voting." - }, - "deposit_params": { - "$ref": "#/definitions/v1beta1DepositParams", - "description": "deposit_params defines the parameters related to deposit." - }, - "tally_params": { - "$ref": "#/definitions/v1beta1TallyParams", - "description": "tally_params defines the parameters related to tally." - } - }, - "description": "QueryParamsResponse is the response type for the Query/Params RPC method." - }, - "v1beta1QueryProposalResponse": { - "type": "object", - "properties": { - "proposal": { - "$ref": "#/definitions/v1beta1Proposal" - } - }, - "description": "QueryProposalResponse is the response type for the Query/Proposal RPC method." - }, - "v1beta1QueryProposalsResponse": { - "type": "object", - "properties": { - "proposals": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1Proposal" - } - }, - "pagination": { - "$ref": "#/definitions/v1beta1PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryProposalsResponse is the response type for the Query/Proposals RPC method." - }, - "v1beta1QueryTallyResultResponse": { - "type": "object", - "properties": { - "tally": { - "$ref": "#/definitions/v1beta1TallyResult", - "description": "tally defines the requested tally." - } - }, - "description": "QueryTallyResultResponse is the response type for the Query/Tally RPC method." - }, - "v1beta1QueryVoteResponse": { - "type": "object", - "properties": { - "vote": { - "$ref": "#/definitions/v1beta1Vote", - "description": "vote defined the queried vote." - } - }, - "description": "QueryVoteResponse is the response type for the Query/Vote RPC method." - }, - "v1beta1QueryVotesResponse": { - "type": "object", - "properties": { - "votes": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1Vote" - }, - "description": "votes defined the queried votes." - }, - "pagination": { - "$ref": "#/definitions/v1beta1PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryVotesResponse is the response type for the Query/Votes RPC method." - }, - "v1beta1TallyParams": { - "type": "object", - "properties": { - "quorum": { - "type": "string", - "format": "byte", - "description": "Minimum percentage of total stake needed to vote for a result to be considered valid." - }, - "threshold": { - "type": "string", - "format": "byte", - "description": "Minimum proportion of Yes votes for proposal to pass. Initial value: 0.5." - }, - "veto": { - "type": "string", - "format": "byte", - "description": "Minimum value of Veto votes to Total votes ratio for proposal to be vetoed. Initial value: 1/3." - } - }, - "title": "TallyParams defines the params around Tallying votes in governance" - }, - "v1beta1TallyResult": { - "type": "object", - "properties": { - "yes": { - "type": "string" - }, - "abstain": { - "type": "string" - }, - "no": { - "type": "string" - }, - "no_with_veto": { - "type": "string" - } - }, - "title": "TallyResult defines a standard tally for a proposal" - }, - "v1beta1Vote": { - "type": "object", - "properties": { - "proposal_id": { - "type": "string", - "format": "uint64" - }, - "voter": { - "type": "string", - "format": "byte" - }, - "option": { - "$ref": "#/definitions/v1beta1VoteOption" - } - }, - "description": "Vote defines a vote on a governance proposal. A vote corresponds to a proposal\nID, the voter, and the vote option." - }, - "v1beta1VoteOption": { - "type": "string", - "enum": [ - "VOTE_OPTION_UNSPECIFIED", - "VOTE_OPTION_YES", - "VOTE_OPTION_ABSTAIN", - "VOTE_OPTION_NO", - "VOTE_OPTION_NO_WITH_VETO" - ], - "default": "VOTE_OPTION_UNSPECIFIED", - "description": "- VOTE_OPTION_UNSPECIFIED: VOTE_OPTION_UNSPECIFIED defines a no-op vote option.\n - VOTE_OPTION_YES: VOTE_OPTION_YES defines a yes vote option.\n - VOTE_OPTION_ABSTAIN: VOTE_OPTION_ABSTAIN defines an abstain vote option.\n - VOTE_OPTION_NO: VOTE_OPTION_NO defines a no vote option.\n - VOTE_OPTION_NO_WITH_VETO: VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option.", - "title": "VoteOption defines a vote option" - }, - "v1beta1VotingParams": { - "type": "object", - "properties": { - "voting_period": { - "type": "string", - "description": "Length of the voting period." - } - }, - "title": "VotingParams defines the params around Voting in governance" - } - } -} diff --git a/x/ibc/channel/query.swagger.json b/x/ibc/channel/query.swagger.json deleted file mode 100644 index e4e5ffc103fe..000000000000 --- a/x/ibc/channel/query.swagger.json +++ /dev/null @@ -1,982 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "ibc/channel/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/ibc/channel/v1beta1/channels": { - "get": { - "summary": "Channels queries all the IBC channels of a chain.", - "operationId": "Query_Channels", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/channelQueryChannelsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}": { - "get": { - "summary": "Channel queries an IBC Channel.", - "operationId": "Query_Channel", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/channelQueryChannelResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "channel_id", - "description": "channel unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "port_id", - "description": "port unique identifier", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/client_state": { - "get": { - "summary": "ChannelClientState queries for the client state for the channel associated\nwith the provided channel identifiers.", - "operationId": "Query_ChannelClientState", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/channelQueryChannelClientStateResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "channel_id", - "description": "channel unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "port_id", - "description": "port unique identifier", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/consensus_state/{height}": { - "get": { - "summary": "ChannelConsensusState queries for the consensus state for the channel\nassociated with the provided channel identifiers.", - "operationId": "Query_ChannelConsensusState", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/channelQueryChannelConsensusStateResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "channel_id", - "description": "channel unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "port_id", - "description": "port unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "height", - "description": "height of the consensus state", - "in": "path", - "required": true, - "type": "string", - "format": "uint64" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/next_sequence": { - "get": { - "summary": "NextSequenceReceive returns the next receive sequence for a given channel.", - "operationId": "Query_NextSequenceReceive", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/channelQueryNextSequenceReceiveResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "channel_id", - "description": "channel unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "port_id", - "description": "port unique identifier", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_acks/{sequence}": { - "get": { - "summary": "PacketAcknowledgement queries a stored packet acknowledgement hash.", - "operationId": "Query_PacketAcknowledgement", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/channelQueryPacketAcknowledgementResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "channel_id", - "description": "channel unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "port_id", - "description": "port unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "sequence", - "description": "packet sequence", - "in": "path", - "required": true, - "type": "string", - "format": "uint64" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments": { - "get": { - "summary": "PacketCommitments returns the all the packet commitments hashes associated\nwith a channel.", - "operationId": "Query_PacketCommitments", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/channelQueryPacketCommitmentsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "channel_id", - "description": "channel unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "port_id", - "description": "port unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_commitment_sequences}/packet_acks/{acknowledgements}/unrelayed_packets": { - "get": { - "summary": "UnrelayedPackets returns all the unrelayed IBC packets associated with a\nchannel and sequences.", - "operationId": "Query_UnrelayedPackets", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/channelQueryUnrelayedPacketsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "channel_id", - "description": "channel unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "port_id", - "description": "port unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "packet_commitment_sequences", - "description": "list of packet sequences", - "in": "path", - "required": true, - "type": "array", - "items": { - "type": "string", - "format": "uint64" - }, - "collectionFormat": "csv", - "minItems": 1 - }, - { - "name": "acknowledgements", - "description": "flag indicating if the return value is packet commitments or\nacknowledgements", - "in": "path", - "required": true, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/{sequence}": { - "get": { - "summary": "PacketCommitment queries a stored packet commitment hash.", - "operationId": "Query_PacketCommitment", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/channelQueryPacketCommitmentResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "channel_id", - "description": "channel unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "port_id", - "description": "port unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "sequence", - "description": "packet sequence", - "in": "path", - "required": true, - "type": "string", - "format": "uint64" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/channel/v1beta1/connections/{connection}/channels": { - "get": { - "summary": "ConnectionChannels queries all the channels associated with a connection\nend.", - "operationId": "Query_ConnectionChannels", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/channelQueryConnectionChannelsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "connection", - "description": "connection unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "channelChannel": { - "type": "object", - "properties": { - "state": { - "$ref": "#/definitions/channelState", - "title": "current state of the channel end" - }, - "ordering": { - "$ref": "#/definitions/channelOrder", - "title": "whether the channel is ordered or unordered" - }, - "counterparty": { - "$ref": "#/definitions/channelCounterparty", - "title": "counterparty channel end" - }, - "connection_hops": { - "type": "array", - "items": { - "type": "string" - }, - "title": "list of connection identifiers, in order, along which packets sent on this\nchannel will travel" - }, - "version": { - "type": "string", - "title": "opaque channel version, which is agreed upon during the handshake" - } - }, - "description": "Channel defines pipeline for exactly-once packet delivery between specific\nmodules on separate blockchains, which has at least one end capable of sending\npackets and one end capable of receiving packets." - }, - "channelCounterparty": { - "type": "object", - "properties": { - "port_id": { - "type": "string", - "description": "port on the counterparty chain which owns the other end of the channel." - }, - "channel_id": { - "type": "string", - "title": "channel end on the counterparty chain" - } - }, - "title": "Counterparty defines a channel end counterparty" - }, - "channelIdentifiedChannel": { - "type": "object", - "properties": { - "state": { - "$ref": "#/definitions/channelState", - "title": "current state of the channel end" - }, - "ordering": { - "$ref": "#/definitions/channelOrder", - "title": "whether the channel is ordered or unordered" - }, - "counterparty": { - "$ref": "#/definitions/channelCounterparty", - "title": "counterparty channel end" - }, - "connection_hops": { - "type": "array", - "items": { - "type": "string" - }, - "title": "list of connection identifiers, in order, along which packets sent on this\nchannel will travel" - }, - "version": { - "type": "string", - "title": "opaque channel version, which is agreed upon during the handshake" - }, - "port_id": { - "type": "string", - "title": "port identifier" - }, - "channel_id": { - "type": "string", - "title": "channel identifier" - } - }, - "description": "IdentifiedChannel defines a channel with additional port and channel identifier\nfields." - }, - "channelOrder": { - "type": "string", - "enum": [ - "ORDER_NONE_UNSPECIFIED", - "ORDER_UNORDERED", - "ORDER_ORDERED" - ], - "default": "ORDER_NONE_UNSPECIFIED", - "description": "- ORDER_NONE_UNSPECIFIED: zero-value for channel ordering\n - ORDER_UNORDERED: packets can be delivered in any order, which may differ from the order in which they were sent.\n - ORDER_ORDERED: packets are delivered exactly in the order which they were sent", - "title": "Order defines if a channel is ORDERED or UNORDERED" - }, - "channelPacketAckCommitment": { - "type": "object", - "properties": { - "port_id": { - "type": "string", - "description": "channel port identifier." - }, - "channel_id": { - "type": "string", - "description": "channel unique identifier." - }, - "sequence": { - "type": "string", - "format": "uint64", - "description": "packet sequence." - }, - "hash": { - "type": "string", - "format": "byte", - "description": "packet commitment hash." - } - }, - "description": "PacketAckCommitment defines the genesis type necessary to retrieve and store\nacknowlegements." - }, - "channelQueryChannelClientStateResponse": { - "type": "object", - "properties": { - "identified_client_state": { - "$ref": "#/definitions/clientIdentifiedClientState", - "title": "client state associated with the channel" - }, - "proof": { - "type": "string", - "format": "byte", - "title": "merkle proof of existence" - }, - "proof_path": { - "type": "string", - "title": "merkle proof path" - }, - "proof_height": { - "type": "string", - "format": "uint64", - "title": "height at which the proof was retrieved" - } - }, - "title": "QueryChannelClientStateResponse is the Response type for the\nQuery/QueryChannelClientState RPC method" - }, - "channelQueryChannelConsensusStateResponse": { - "type": "object", - "properties": { - "consensus_state": { - "$ref": "#/definitions/protobufAny", - "title": "consensus state associated with the channel" - }, - "client_id": { - "type": "string", - "title": "client ID associated with the consensus state" - }, - "proof": { - "type": "string", - "format": "byte", - "title": "merkle proof of existence" - }, - "proof_path": { - "type": "string", - "title": "merkle proof path" - }, - "proof_height": { - "type": "string", - "format": "uint64", - "title": "height at which the proof was retrieved" - } - }, - "title": "QueryChannelClientStateResponse is the Response type for the\nQuery/QueryChannelClientState RPC method" - }, - "channelQueryChannelResponse": { - "type": "object", - "properties": { - "channel": { - "$ref": "#/definitions/channelChannel", - "title": "channel associated with the request identifiers" - }, - "proof": { - "type": "string", - "format": "byte", - "title": "merkle proof of existence" - }, - "proof_path": { - "type": "string", - "title": "merkle proof path" - }, - "proof_height": { - "type": "string", - "format": "uint64", - "title": "height at which the proof was retrieved" - } - }, - "description": "QueryChannelResponse is the response type for the Query/Channel RPC method.\nBesides the Channel end, it includes a proof and the height from which the\nproof was retrieved." - }, - "channelQueryChannelsResponse": { - "type": "object", - "properties": { - "channels": { - "type": "array", - "items": { - "$ref": "#/definitions/channelIdentifiedChannel" - }, - "description": "list of stored channels of the chain." - }, - "pagination": { - "$ref": "#/definitions/v1beta1PageResponse", - "title": "pagination response" - }, - "height": { - "type": "string", - "format": "int64", - "title": "query block height" - } - }, - "description": "QueryChannelsResponse is the response type for the Query/Channels RPC method." - }, - "channelQueryConnectionChannelsResponse": { - "type": "object", - "properties": { - "channels": { - "type": "array", - "items": { - "$ref": "#/definitions/channelIdentifiedChannel" - }, - "description": "list of channels associated with a connection." - }, - "pagination": { - "$ref": "#/definitions/v1beta1PageResponse", - "title": "pagination response" - }, - "height": { - "type": "string", - "format": "int64", - "title": "query block height" - } - }, - "title": "QueryConnectionChannelsResponse is the Response type for the\nQuery/QueryConnectionChannels RPC method" - }, - "channelQueryNextSequenceReceiveResponse": { - "type": "object", - "properties": { - "next_sequence_receive": { - "type": "string", - "format": "uint64", - "title": "next sequence receive number" - }, - "proof": { - "type": "string", - "format": "byte", - "title": "merkle proof of existence" - }, - "proof_path": { - "type": "string", - "title": "merkle proof path" - }, - "proof_height": { - "type": "string", - "format": "uint64", - "title": "height at which the proof was retrieved" - } - }, - "title": "QuerySequenceResponse is the request type for the\nQuery/QueryNextSequenceReceiveResponse RPC method" - }, - "channelQueryPacketAcknowledgementResponse": { - "type": "object", - "properties": { - "acknowledgement": { - "type": "string", - "format": "byte", - "title": "packet associated with the request fields" - }, - "proof": { - "type": "string", - "format": "byte", - "title": "merkle proof of existence" - }, - "proof_path": { - "type": "string", - "title": "merkle proof path" - }, - "proof_height": { - "type": "string", - "format": "uint64", - "title": "height at which the proof was retrieved" - } - }, - "title": "QueryPacketAcknowledgementResponse defines the client query response for a\npacket which also includes a proof, its path and the height form which the\nproof was retrieved" - }, - "channelQueryPacketCommitmentResponse": { - "type": "object", - "properties": { - "commitment": { - "type": "string", - "format": "byte", - "title": "packet associated with the request fields" - }, - "proof": { - "type": "string", - "format": "byte", - "title": "merkle proof of existence" - }, - "proof_path": { - "type": "string", - "title": "merkle proof path" - }, - "proof_height": { - "type": "string", - "format": "uint64", - "title": "height at which the proof was retrieved" - } - }, - "title": "QueryPacketCommitmentResponse defines the client query response for a packet\nwhich also includes a proof, its path and the height form which the proof was\nretrieved" - }, - "channelQueryPacketCommitmentsResponse": { - "type": "object", - "properties": { - "commitments": { - "type": "array", - "items": { - "$ref": "#/definitions/channelPacketAckCommitment" - } - }, - "pagination": { - "$ref": "#/definitions/v1beta1PageResponse", - "title": "pagination response" - }, - "height": { - "type": "string", - "format": "int64", - "title": "query block height" - } - }, - "title": "QueryPacketCommitmentsResponse is the request type for the\nQuery/QueryPacketCommitments RPC method" - }, - "channelQueryUnrelayedPacketsResponse": { - "type": "object", - "properties": { - "sequences": { - "type": "array", - "items": { - "type": "string", - "format": "uint64" - }, - "title": "list of unrelayed packet sequences" - }, - "height": { - "type": "string", - "format": "int64", - "title": "query block height" - } - }, - "title": "QueryUnrelayedPacketsResponse is the request type for the\nQuery/UnrelayedPacketCommitments RPC method" - }, - "channelState": { - "type": "string", - "enum": [ - "STATE_UNINITIALIZED_UNSPECIFIED", - "STATE_INIT", - "STATE_TRYOPEN", - "STATE_OPEN", - "STATE_CLOSED" - ], - "default": "STATE_UNINITIALIZED_UNSPECIFIED", - "description": "State defines if a channel is in one of the following states:\nCLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.\n\n - STATE_UNINITIALIZED_UNSPECIFIED: Default State\n - STATE_INIT: A channel has just started the opening handshake.\n - STATE_TRYOPEN: A channel has acknowledged the handshake step on the counterparty chain.\n - STATE_OPEN: A channel has completed the handshake. Open channels are\nready to send and receive packets.\n - STATE_CLOSED: A channel has been closed and can no longer be used to send or receive packets." - }, - "clientIdentifiedClientState": { - "type": "object", - "properties": { - "id": { - "type": "string", - "title": "client identifier" - }, - "client_state": { - "$ref": "#/definitions/protobufAny" - } - }, - "description": "IdentifiedClientState defines a client state with additional client identifier field." - }, - "protobufAny": { - "type": "object", - "properties": { - "type_url": { - "type": "string", - "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." - }, - "value": { - "type": "string", - "format": "byte", - "description": "Must be a valid serialized protocol buffer of the above specified type." - } - }, - "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := \u0026pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" - }, - "runtimeError": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/protobufAny" - } - } - } - }, - "v1beta1PageRequest": { - "type": "object", - "properties": { - "key": { - "type": "string", - "format": "byte", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." - }, - "offset": { - "type": "string", - "format": "uint64", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." - }, - "limit": { - "type": "string", - "format": "uint64", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." - }, - "count_total": { - "type": "boolean", - "format": "boolean", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." - } - }, - "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", - "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" - }, - "v1beta1PageResponse": { - "type": "object", - "properties": { - "next_key": { - "type": "string", - "format": "byte", - "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" - }, - "total": { - "type": "string", - "format": "uint64", - "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" - } - }, - "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" - } - } -} diff --git a/x/ibc/connection/query.swagger.json b/x/ibc/connection/query.swagger.json deleted file mode 100644 index 570052738057..000000000000 --- a/x/ibc/connection/query.swagger.json +++ /dev/null @@ -1,520 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "ibc/connection/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/ibc/connection/v1beta1/client_connections/{client_id}": { - "get": { - "summary": "ClientConnections queries the connection paths associated with a client\nstate.", - "operationId": "Query_ClientConnections", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/connectionQueryClientConnectionsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "client_id", - "description": "client identifier associated with a connection", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/connection/v1beta1/connections": { - "get": { - "summary": "Connections queries all the IBC connections of a chain.", - "operationId": "Query_Connections", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/connectionQueryConnectionsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/connection/v1beta1/connections/{connection_id}": { - "get": { - "summary": "Connection queries an IBC connection end.", - "operationId": "Query_Connection", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/connectionQueryConnectionResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "connection_id", - "description": "connection unique identifier", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/connection/v1beta1/connections/{connection_id}/client_state": { - "get": { - "summary": "ConnectionClientState queries the client state associated with the\nconnection.", - "operationId": "Query_ConnectionClientState", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/connectionQueryConnectionClientStateResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "connection_id", - "description": "connection identifier", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/connection/v1beta1/connections/{connection_id}/consensus_state": { - "get": { - "summary": "ConnectionConsensusState queries the consensus state associated with the\nconnection.", - "operationId": "Query_ConnectionConsensusState", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/connectionQueryConnectionConsensusStateResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "connection_id", - "description": "connection identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "height", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - } - ], - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "clientIdentifiedClientState": { - "type": "object", - "properties": { - "id": { - "type": "string", - "title": "client identifier" - }, - "client_state": { - "$ref": "#/definitions/protobufAny" - } - }, - "description": "IdentifiedClientState defines a client state with additional client identifier field." - }, - "commitmentMerklePrefix": { - "type": "object", - "properties": { - "key_prefix": { - "type": "string", - "format": "byte" - } - }, - "title": "MerklePrefix is merkle path prefixed to the key.\nThe constructed key from the Path and the key will be append(Path.KeyPath, append(Path.KeyPrefix, key...))" - }, - "connectionConnectionEnd": { - "type": "object", - "properties": { - "client_id": { - "type": "string", - "description": "client associated with this connection." - }, - "versions": { - "type": "array", - "items": { - "type": "string" - }, - "title": "IBC version which can be utilised to determine encodings or protocols for\nchannels or packets utilising this connection" - }, - "state": { - "$ref": "#/definitions/connectionState", - "description": "current state of the connection end." - }, - "counterparty": { - "$ref": "#/definitions/connectionCounterparty", - "description": "counterparty chain associated with this connection." - } - }, - "description": "ConnectionEnd defines a stateful object on a chain connected to another\nseparate one. NOTE: there must only be 2 defined ConnectionEnds to establish\na connection between two chains." - }, - "connectionCounterparty": { - "type": "object", - "properties": { - "client_id": { - "type": "string", - "description": "identifies the client on the counterparty chain associated with a given\nconnection." - }, - "connection_id": { - "type": "string", - "description": "identifies the connection end on the counterparty chain associated with a\ngiven connection." - }, - "prefix": { - "$ref": "#/definitions/commitmentMerklePrefix", - "title": "commitment merkle prefix of the counterparty chain" - } - }, - "description": "Counterparty defines the counterparty chain associated with a connection end." - }, - "connectionIdentifiedConnection": { - "type": "object", - "properties": { - "id": { - "type": "string", - "description": "connection identifier." - }, - "client_id": { - "type": "string", - "description": "client associated with this connection." - }, - "versions": { - "type": "array", - "items": { - "type": "string" - }, - "title": "IBC version which can be utilised to determine encodings or protocols for\nchannels or packets utilising this connection" - }, - "state": { - "$ref": "#/definitions/connectionState", - "description": "current state of the connection end." - }, - "counterparty": { - "$ref": "#/definitions/connectionCounterparty", - "description": "counterparty chain associated with this connection." - } - }, - "description": "IdentifiedConnection defines a connection with additional connection\nidentifier field." - }, - "connectionQueryClientConnectionsResponse": { - "type": "object", - "properties": { - "connection_paths": { - "type": "array", - "items": { - "type": "string" - }, - "description": "slice of all the connection paths associated with a client." - }, - "proof": { - "type": "string", - "format": "byte", - "title": "merkle proof of existence" - }, - "proof_path": { - "type": "string", - "title": "merkle proof path" - }, - "proof_height": { - "type": "string", - "format": "uint64", - "title": "height at which the proof was generated" - } - }, - "title": "QueryClientConnectionsResponse is the response type for the\nQuery/ClientConnections RPC method" - }, - "connectionQueryConnectionClientStateResponse": { - "type": "object", - "properties": { - "identified_client_state": { - "$ref": "#/definitions/clientIdentifiedClientState", - "title": "client state associated with the channel" - }, - "proof": { - "type": "string", - "format": "byte", - "title": "merkle proof of existence" - }, - "proof_path": { - "type": "string", - "title": "merkle proof path" - }, - "proof_height": { - "type": "string", - "format": "uint64", - "title": "height at which the proof was retrieved" - } - }, - "title": "QueryConnectionClientStateResponse is the response type for the\nQuery/ConnectionClientState RPC method" - }, - "connectionQueryConnectionConsensusStateResponse": { - "type": "object", - "properties": { - "consensus_state": { - "$ref": "#/definitions/protobufAny", - "title": "consensus state associated with the channel" - }, - "client_id": { - "type": "string", - "title": "client ID associated with the consensus state" - }, - "proof": { - "type": "string", - "format": "byte", - "title": "merkle proof of existence" - }, - "proof_path": { - "type": "string", - "title": "merkle proof path" - }, - "proof_height": { - "type": "string", - "format": "uint64", - "title": "height at which the proof was retrieved" - } - }, - "title": "QueryConnectionConsensusStateResponse is the response type for the\nQuery/ConnectionConsensusState RPC method" - }, - "connectionQueryConnectionResponse": { - "type": "object", - "properties": { - "connection": { - "$ref": "#/definitions/connectionConnectionEnd", - "title": "connection associated with the request identifier" - }, - "proof": { - "type": "string", - "format": "byte", - "title": "merkle proof of existence" - }, - "proof_path": { - "type": "string", - "title": "merkle proof path" - }, - "proof_height": { - "type": "string", - "format": "uint64", - "title": "height at which the proof was retrieved" - } - }, - "description": "QueryConnectionResponse is the response type for the Query/Connection RPC\nmethod. Besides the connection end, it includes a proof and the height from\nwhich the proof was retrieved." - }, - "connectionQueryConnectionsResponse": { - "type": "object", - "properties": { - "connections": { - "type": "array", - "items": { - "$ref": "#/definitions/connectionIdentifiedConnection" - }, - "description": "list of stored connections of the chain." - }, - "pagination": { - "$ref": "#/definitions/v1beta1PageResponse", - "title": "pagination response" - }, - "height": { - "type": "string", - "format": "int64", - "title": "query block height" - } - }, - "description": "QueryConnectionsResponse is the response type for the Query/Connections RPC\nmethod." - }, - "connectionState": { - "type": "string", - "enum": [ - "STATE_UNINITIALIZED_UNSPECIFIED", - "STATE_INIT", - "STATE_TRYOPEN", - "STATE_OPEN" - ], - "default": "STATE_UNINITIALIZED_UNSPECIFIED", - "description": "State defines if a connection is in one of the following states:\nINIT, TRYOPEN, OPEN or UNINITIALIZED.\n\n - STATE_UNINITIALIZED_UNSPECIFIED: Default State\n - STATE_INIT: A connection end has just started the opening handshake.\n - STATE_TRYOPEN: A connection end has acknowledged the handshake step on the counterparty\nchain.\n - STATE_OPEN: A connection end has completed the handshake." - }, - "protobufAny": { - "type": "object", - "properties": { - "type_url": { - "type": "string", - "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." - }, - "value": { - "type": "string", - "format": "byte", - "description": "Must be a valid serialized protocol buffer of the above specified type." - } - }, - "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := \u0026pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" - }, - "runtimeError": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/protobufAny" - } - } - } - }, - "v1beta1PageRequest": { - "type": "object", - "properties": { - "key": { - "type": "string", - "format": "byte", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." - }, - "offset": { - "type": "string", - "format": "uint64", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." - }, - "limit": { - "type": "string", - "format": "uint64", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." - }, - "count_total": { - "type": "boolean", - "format": "boolean", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." - } - }, - "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", - "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" - }, - "v1beta1PageResponse": { - "type": "object", - "properties": { - "next_key": { - "type": "string", - "format": "byte", - "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" - }, - "total": { - "type": "string", - "format": "uint64", - "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" - } - }, - "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" - } - } -} diff --git a/x/ibc/transfer/query.swagger.json b/x/ibc/transfer/query.swagger.json deleted file mode 100644 index 11ec227783a0..000000000000 --- a/x/ibc/transfer/query.swagger.json +++ /dev/null @@ -1,273 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "ibc/transfer/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/ibc_transfer/v1beta1/denom_traces": { - "get": { - "summary": "DenomTraces queries all denomination traces.", - "operationId": "Query_DenomTraces", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/transferQueryDenomTracesResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc_transfer/v1beta1/denom_traces/{hash}": { - "get": { - "summary": "DenomTrace queries a denomination trace information.", - "operationId": "Query_DenomTrace", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/transferQueryDenomTraceResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "hash", - "description": "hash (in hex format) of the denomination trace information.", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc_transfer/v1beta1/params": { - "get": { - "summary": "Params queries all parameters of the ibc-transfer module.", - "operationId": "Query_Params", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/transferQueryParamsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "protobufAny": { - "type": "object", - "properties": { - "type_url": { - "type": "string" - }, - "value": { - "type": "string", - "format": "byte" - } - } - }, - "runtimeError": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/protobufAny" - } - } - } - }, - "transferDenomTrace": { - "type": "object", - "properties": { - "path": { - "type": "string", - "description": "path defines the chain of port/channel identifiers used for tracing the source of the fungible\ntoken." - }, - "base_denom": { - "type": "string", - "description": "base denomination of the relayed fungible token." - } - }, - "description": "DenomTrace contains the base denomination for ICS20 fungible tokens and the source tracing\ninformation path." - }, - "transferParams": { - "type": "object", - "properties": { - "send_enabled": { - "type": "boolean", - "format": "boolean", - "description": "send_enabled enables or disables all cross-chain token transfers from this chain." - }, - "receive_enabled": { - "type": "boolean", - "format": "boolean", - "description": "receive_enabled enables or disables all cross-chain token transfers to this chain." - } - }, - "description": "Params defines the set of IBC transfer parameters.\nNOTE: To prevent a single token from being transferred, set the TransfersEnabled parameter to\ntrue and then set the bank module's SendEnabled parameter for the denomination to false." - }, - "transferQueryDenomTraceResponse": { - "type": "object", - "properties": { - "denom_trace": { - "$ref": "#/definitions/transferDenomTrace", - "description": "denom_trace returns the requested denomination trace information." - } - }, - "description": "QueryDenomTraceResponse is the response type for the Query/DenomTrace RPC method." - }, - "transferQueryDenomTracesResponse": { - "type": "object", - "properties": { - "denom_traces": { - "type": "array", - "items": { - "$ref": "#/definitions/transferDenomTrace" - }, - "description": "denom_traces returns all denominations trace information." - }, - "pagination": { - "$ref": "#/definitions/v1beta1PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryConnectionsResponse is the response type for the Query/DenomTraces RPC method." - }, - "transferQueryParamsResponse": { - "type": "object", - "properties": { - "params": { - "$ref": "#/definitions/transferParams", - "description": "params defines the parameters of the module." - } - }, - "description": "QueryParamsResponse is the response type for the Query/Params RPC method." - }, - "v1beta1PageRequest": { - "type": "object", - "properties": { - "key": { - "type": "string", - "format": "byte", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." - }, - "offset": { - "type": "string", - "format": "uint64", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." - }, - "limit": { - "type": "string", - "format": "uint64", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." - }, - "count_total": { - "type": "boolean", - "format": "boolean", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." - } - }, - "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", - "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" - }, - "v1beta1PageResponse": { - "type": "object", - "properties": { - "next_key": { - "type": "string", - "format": "byte", - "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" - }, - "total": { - "type": "string", - "format": "uint64", - "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" - } - }, - "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" - } - } -} diff --git a/x/mint/v1beta1/query.swagger.json b/x/mint/v1beta1/query.swagger.json deleted file mode 100644 index b9bc1d0e1767..000000000000 --- a/x/mint/v1beta1/query.swagger.json +++ /dev/null @@ -1,182 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "cosmos/mint/v1beta1/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/cosmos/mint/v1beta1/annual_provisions": { - "get": { - "summary": "AnnualProvisions current minting annual provisions value.", - "operationId": "Query_AnnualProvisions", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryAnnualProvisionsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "tags": [ - "Query" - ] - } - }, - "/cosmos/mint/v1beta1/inflation": { - "get": { - "summary": "Inflation returns the current minting inflation value.", - "operationId": "Query_Inflation", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryInflationResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "tags": [ - "Query" - ] - } - }, - "/cosmos/mint/v1beta1/params": { - "get": { - "summary": "Params returns the total set of minting parameters.", - "operationId": "Query_Params", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryParamsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "protobufAny": { - "type": "object", - "properties": { - "type_url": { - "type": "string" - }, - "value": { - "type": "string", - "format": "byte" - } - } - }, - "runtimeError": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/protobufAny" - } - } - } - }, - "v1beta1Params": { - "type": "object", - "properties": { - "mint_denom": { - "type": "string", - "title": "type of coin to mint" - }, - "inflation_rate_change": { - "type": "string", - "title": "maximum annual change in inflation rate" - }, - "inflation_max": { - "type": "string", - "title": "maximum inflation rate" - }, - "inflation_min": { - "type": "string", - "title": "minimum inflation rate" - }, - "goal_bonded": { - "type": "string", - "title": "goal of percent bonded atoms" - }, - "blocks_per_year": { - "type": "string", - "format": "uint64", - "title": "expected blocks per year" - } - }, - "title": "mint parameters" - }, - "v1beta1QueryAnnualProvisionsResponse": { - "type": "object", - "properties": { - "annual_provisions": { - "type": "string", - "format": "byte", - "description": "annual_provisions is the current minting annual provisions value." - } - }, - "description": "QueryAnnualProvisionsResponse is the response type for the Query/AnnualProvisions RPC method." - }, - "v1beta1QueryInflationResponse": { - "type": "object", - "properties": { - "inflation": { - "type": "string", - "format": "byte", - "description": "inflation is the current minting inflation value." - } - }, - "description": "QueryInflationResponse is the response type for the Query/Inflation RPC method." - }, - "v1beta1QueryParamsResponse": { - "type": "object", - "properties": { - "params": { - "$ref": "#/definitions/v1beta1Params", - "description": "params defines the parameters of the module." - } - }, - "description": "QueryParamsResponse is the response type for the Query/Params RPC method." - } - } -} diff --git a/x/params/v1beta1/query.swagger.json b/x/params/v1beta1/query.swagger.json deleted file mode 100644 index f24fcd582ba0..000000000000 --- a/x/params/v1beta1/query.swagger.json +++ /dev/null @@ -1,114 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "cosmos/params/v1beta1/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/cosmos/params/v1beta1/params": { - "get": { - "summary": "Params queries a specific parameter of a module, given its subspace and key.", - "operationId": "Query_Params", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryParamsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "subspace", - "description": "subspace defines the module to query the parameter for.", - "in": "query", - "required": false, - "type": "string" - }, - { - "name": "key", - "description": "key defines the key of the parameter in the subspace.", - "in": "query", - "required": false, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "protobufAny": { - "type": "object", - "properties": { - "type_url": { - "type": "string" - }, - "value": { - "type": "string", - "format": "byte" - } - } - }, - "runtimeError": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/protobufAny" - } - } - } - }, - "v1beta1ParamChange": { - "type": "object", - "properties": { - "subspace": { - "type": "string" - }, - "key": { - "type": "string" - }, - "value": { - "type": "string" - } - }, - "description": "ParamChange defines a parameter change." - }, - "v1beta1QueryParamsResponse": { - "type": "object", - "properties": { - "param": { - "$ref": "#/definitions/v1beta1ParamChange", - "description": "param defines the queried parameter." - } - }, - "description": "QueryParamsResponse is response type for the Query/Params RPC method." - } - } -} diff --git a/x/slashing/v1beta1/query.swagger.json b/x/slashing/v1beta1/query.swagger.json deleted file mode 100644 index 6144e41a78a8..000000000000 --- a/x/slashing/v1beta1/query.swagger.json +++ /dev/null @@ -1,302 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "cosmos/slashing/v1beta1/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/cosmos/slashing/v1beta1/params": { - "get": { - "summary": "Params queries the parameters of slashing module", - "operationId": "Query_Params", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryParamsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "tags": [ - "Query" - ] - } - }, - "/cosmos/slashing/v1beta1/signing_infos": { - "get": { - "summary": "SigningInfos queries signing info of all validators", - "operationId": "Query_SigningInfos", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QuerySigningInfosResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/slashing/v1beta1/signing_infos/{cons_address}": { - "get": { - "summary": "SigningInfo queries the signing info of given cons address", - "operationId": "Query_SigningInfo", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QuerySigningInfoResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "cons_address", - "description": "cons_address is the address to query signing info of", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "protobufAny": { - "type": "object", - "properties": { - "type_url": { - "type": "string" - }, - "value": { - "type": "string", - "format": "byte" - } - } - }, - "runtimeError": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/protobufAny" - } - } - } - }, - "v1beta1PageRequest": { - "type": "object", - "properties": { - "key": { - "type": "string", - "format": "byte", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." - }, - "offset": { - "type": "string", - "format": "uint64", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." - }, - "limit": { - "type": "string", - "format": "uint64", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." - }, - "count_total": { - "type": "boolean", - "format": "boolean", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." - } - }, - "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", - "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" - }, - "v1beta1PageResponse": { - "type": "object", - "properties": { - "next_key": { - "type": "string", - "format": "byte", - "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" - }, - "total": { - "type": "string", - "format": "uint64", - "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" - } - }, - "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" - }, - "v1beta1Params": { - "type": "object", - "properties": { - "signed_blocks_window": { - "type": "string", - "format": "int64" - }, - "min_signed_per_window": { - "type": "string", - "format": "byte" - }, - "downtime_jail_duration": { - "type": "string" - }, - "slash_fraction_double_sign": { - "type": "string", - "format": "byte" - }, - "slash_fraction_downtime": { - "type": "string", - "format": "byte" - } - }, - "title": "Params - used for initializing default parameter for slashing at genesis" - }, - "v1beta1QueryParamsResponse": { - "type": "object", - "properties": { - "params": { - "$ref": "#/definitions/v1beta1Params" - } - }, - "title": "QueryParamsResponse is the response type for the Query/Params RPC method" - }, - "v1beta1QuerySigningInfoResponse": { - "type": "object", - "properties": { - "val_signing_info": { - "$ref": "#/definitions/v1beta1ValidatorSigningInfo", - "title": "val_signing_info is the signing info of requested val cons address" - } - }, - "title": "QuerySigningInfoResponse is the response type for the Query/SigningInfo RPC method" - }, - "v1beta1QuerySigningInfosResponse": { - "type": "object", - "properties": { - "info": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1ValidatorSigningInfo" - }, - "title": "info is the signing info of all validators" - }, - "pagination": { - "$ref": "#/definitions/v1beta1PageResponse" - } - }, - "title": "QuerySigningInfosResponse is the response type for the Query/SigningInfos RPC method" - }, - "v1beta1ValidatorSigningInfo": { - "type": "object", - "properties": { - "address": { - "type": "string", - "format": "byte" - }, - "start_height": { - "type": "string", - "format": "int64", - "title": "height at which validator was first a candidate OR was unjailed" - }, - "index_offset": { - "type": "string", - "format": "int64", - "title": "index offset into signed block bit array" - }, - "jailed_until": { - "type": "string", - "format": "date-time", - "title": "timestamp validator cannot be unjailed until" - }, - "tombstoned": { - "type": "boolean", - "format": "boolean", - "title": "whether or not a validator has been tombstoned (killed out of validator set)" - }, - "missed_blocks_counter": { - "type": "string", - "format": "int64", - "title": "missed blocks counter (to avoid scanning the array every time)" - } - }, - "title": "ValidatorSigningInfo defines the signing info for a validator" - } - } -} diff --git a/x/staking/v1beta1/query.swagger.json b/x/staking/v1beta1/query.swagger.json deleted file mode 100644 index bf0792862b2a..000000000000 --- a/x/staking/v1beta1/query.swagger.json +++ /dev/null @@ -1,1385 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "cosmos/staking/v1beta1/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/cosmos/staking/v1beta1/delegations/{delegator_addr}": { - "get": { - "summary": "DelegatorDelegations queries all delegations of a given delegator address.", - "operationId": "Query_DelegatorDelegations", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryDelegatorDelegationsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "delegator_addr", - "description": "delegator_addr defines the delegator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/delegators/{delegator_addr}/redelegations": { - "get": { - "summary": "Redelegations queries redelegations of given address.", - "operationId": "Query_Redelegations", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryRedelegationsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "delegator_addr", - "description": "delegator_addr defines the delegator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "src_validator_addr", - "description": "src_validator_addr defines the validator address to redelegate from.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "dst_validator_addr", - "description": "dst_validator_addr defines the validator address to redelegate to.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/delegators/{delegator_addr}/unbonding_delegations": { - "get": { - "summary": "DelegatorUnbondingDelegations queries all unbonding delegations of a given delegator address.", - "operationId": "Query_DelegatorUnbondingDelegations", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryDelegatorUnbondingDelegationsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "delegator_addr", - "description": "delegator_addr defines the delegator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators": { - "get": { - "summary": "DelegatorValidators queries all validators info for given delegator address.", - "operationId": "Query_DelegatorValidators", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryDelegatorValidatorsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "delegator_addr", - "description": "delegator_addr defines the delegator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators/{validator_addr}": { - "get": { - "summary": "DelegatorValidator queries validator info for given delegator validator pair.", - "operationId": "Query_DelegatorValidator", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryDelegatorValidatorResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "delegator_addr", - "description": "delegator_addr defines the delegator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "validator_addr", - "description": "validator_addr defines the validator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/historical_info/{height}": { - "get": { - "summary": "HistoricalInfo queries the historical info for given height.", - "operationId": "Query_HistoricalInfo", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryHistoricalInfoResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "height", - "description": "height defines at which height to query the historical info.", - "in": "path", - "required": true, - "type": "string", - "format": "int64" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/params": { - "get": { - "summary": "Parameters queries the staking parameters.", - "operationId": "Query_Params", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryParamsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/pool": { - "get": { - "summary": "Pool queries the pool info.", - "operationId": "Query_Pool", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryPoolResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/validators": { - "get": { - "summary": "Validators queries all validators that match the given status.", - "operationId": "Query_Validators", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryValidatorsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "status", - "description": "status enables to query for validators matching a given status.", - "in": "query", - "required": false, - "type": "string" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/validators/{validator_addr}": { - "get": { - "summary": "Validator queries validator info for given validator address.", - "operationId": "Query_Validator", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryValidatorResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "validator_addr", - "description": "validator_addr defines the validator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/validators/{validator_addr}/delegations": { - "get": { - "summary": "ValidatorDelegations queries delegate info for given validator.", - "operationId": "Query_ValidatorDelegations", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryValidatorDelegationsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "validator_addr", - "description": "validator_addr defines the validator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}": { - "get": { - "summary": "Delegation queries delegate info for given validator delegator pair.", - "operationId": "Query_Delegation", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryDelegationResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "validator_addr", - "description": "validator_addr defines the validator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "delegator_addr", - "description": "delegator_addr defines the delegator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}/unbonding_delegation": { - "get": { - "summary": "UnbondingDelegation queries unbonding info for given validator delegator pair.", - "operationId": "Query_UnbondingDelegation", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryUnbondingDelegationResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "validator_addr", - "description": "validator_addr defines the validator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "delegator_addr", - "description": "delegator_addr defines the delegator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/validators/{validator_addr}/unbonding_delegations": { - "get": { - "summary": "ValidatorUnbondingDelegations queries unbonding delegations of a validator.", - "operationId": "Query_ValidatorUnbondingDelegations", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryValidatorUnbondingDelegationsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "validator_addr", - "description": "validator_addr defines the validator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "protobufAny": { - "type": "object", - "properties": { - "type_url": { - "type": "string" - }, - "value": { - "type": "string", - "format": "byte" - } - } - }, - "runtimeError": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/protobufAny" - } - } - } - }, - "typesBlockID": { - "type": "object", - "properties": { - "hash": { - "type": "string", - "format": "byte" - }, - "part_set_header": { - "$ref": "#/definitions/typesPartSetHeader" - } - }, - "title": "BlockID" - }, - "typesHeader": { - "type": "object", - "properties": { - "version": { - "$ref": "#/definitions/versionConsensus", - "title": "basic block info" - }, - "chain_id": { - "type": "string" - }, - "height": { - "type": "string", - "format": "int64" - }, - "time": { - "type": "string", - "format": "date-time" - }, - "last_block_id": { - "$ref": "#/definitions/typesBlockID", - "title": "prev block info" - }, - "last_commit_hash": { - "type": "string", - "format": "byte", - "title": "hashes of block data" - }, - "data_hash": { - "type": "string", - "format": "byte" - }, - "validators_hash": { - "type": "string", - "format": "byte", - "title": "hashes from the app output from the prev block" - }, - "next_validators_hash": { - "type": "string", - "format": "byte" - }, - "consensus_hash": { - "type": "string", - "format": "byte" - }, - "app_hash": { - "type": "string", - "format": "byte" - }, - "last_results_hash": { - "type": "string", - "format": "byte" - }, - "evidence_hash": { - "type": "string", - "format": "byte", - "title": "consensus info" - }, - "proposer_address": { - "type": "string", - "format": "byte" - } - }, - "description": "Header defines the structure of a Tendermint block header." - }, - "typesPartSetHeader": { - "type": "object", - "properties": { - "total": { - "type": "integer", - "format": "int64" - }, - "hash": { - "type": "string", - "format": "byte" - } - }, - "title": "PartsetHeader" - }, - "v1beta1Coin": { - "type": "object", - "properties": { - "denom": { - "type": "string" - }, - "amount": { - "type": "string" - } - }, - "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." - }, - "v1beta1Commission": { - "type": "object", - "properties": { - "commission_rates": { - "$ref": "#/definitions/v1beta1CommissionRates" - }, - "update_time": { - "type": "string", - "format": "date-time" - } - }, - "description": "Commission defines a commission parameters for a given validator." - }, - "v1beta1CommissionRates": { - "type": "object", - "properties": { - "rate": { - "type": "string" - }, - "max_rate": { - "type": "string" - }, - "max_change_rate": { - "type": "string" - } - }, - "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." - }, - "v1beta1Delegation": { - "type": "object", - "properties": { - "delegator_address": { - "type": "string", - "format": "byte" - }, - "validator_address": { - "type": "string", - "format": "byte" - }, - "shares": { - "type": "string" - } - }, - "description": "Delegation represents the bond with tokens held by an account. It is\nowned by one delegator, and is associated with the voting power of one\nvalidator." - }, - "v1beta1DelegationResponse": { - "type": "object", - "properties": { - "delegation": { - "$ref": "#/definitions/v1beta1Delegation" - }, - "balance": { - "$ref": "#/definitions/v1beta1Coin" - } - }, - "description": "DelegationResponse is equivalent to Delegation except that it contains a balance\nin addition to shares which is more suitable for client responses." - }, - "v1beta1Description": { - "type": "object", - "properties": { - "moniker": { - "type": "string" - }, - "identity": { - "type": "string" - }, - "website": { - "type": "string" - }, - "security_contact": { - "type": "string" - }, - "details": { - "type": "string" - } - }, - "description": "Description defines a validator description." - }, - "v1beta1HistoricalInfo": { - "type": "object", - "properties": { - "header": { - "$ref": "#/definitions/typesHeader" - }, - "valset": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1Validator" - } - } - }, - "description": "HistoricalInfo contains the historical information that gets stored at\neach height." - }, - "v1beta1PageRequest": { - "type": "object", - "properties": { - "key": { - "type": "string", - "format": "byte", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." - }, - "offset": { - "type": "string", - "format": "uint64", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." - }, - "limit": { - "type": "string", - "format": "uint64", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." - }, - "count_total": { - "type": "boolean", - "format": "boolean", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." - } - }, - "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", - "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" - }, - "v1beta1PageResponse": { - "type": "object", - "properties": { - "next_key": { - "type": "string", - "format": "byte", - "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" - }, - "total": { - "type": "string", - "format": "uint64", - "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" - } - }, - "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" - }, - "v1beta1Params": { - "type": "object", - "properties": { - "unbonding_time": { - "type": "string" - }, - "max_validators": { - "type": "integer", - "format": "int64" - }, - "max_entries": { - "type": "integer", - "format": "int64" - }, - "historical_entries": { - "type": "integer", - "format": "int64" - }, - "bond_denom": { - "type": "string" - } - }, - "description": "Params defines the parameters for the staking module." - }, - "v1beta1Pool": { - "type": "object", - "properties": { - "not_bonded_tokens": { - "type": "string" - }, - "bonded_tokens": { - "type": "string" - } - }, - "title": "Pool - tracking bonded and not-bonded token supply of the bond denomination" - }, - "v1beta1QueryDelegationResponse": { - "type": "object", - "properties": { - "delegation_response": { - "$ref": "#/definitions/v1beta1DelegationResponse", - "description": "delegation_responses defines the delegation info of a delegation." - } - }, - "description": "QueryDelegationResponse is response type for the Query/Delegation RPC method." - }, - "v1beta1QueryDelegatorDelegationsResponse": { - "type": "object", - "properties": { - "delegation_responses": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1DelegationResponse" - }, - "description": "delegation_responses defines all the delegations' info of a delegator." - }, - "pagination": { - "$ref": "#/definitions/v1beta1PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryDelegatorDelegationsResponse is response type for the Query/DelegatorDelegations RPC method." - }, - "v1beta1QueryDelegatorUnbondingDelegationsResponse": { - "type": "object", - "properties": { - "unbonding_responses": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1UnbondingDelegation" - } - }, - "pagination": { - "$ref": "#/definitions/v1beta1PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryUnbondingDelegatorDelegationsResponse is response type for the Query/UnbondingDelegatorDelegations RPC method." - }, - "v1beta1QueryDelegatorValidatorResponse": { - "type": "object", - "properties": { - "validator": { - "$ref": "#/definitions/v1beta1Validator", - "description": "validator defines the the validator info." - } - }, - "description": "QueryDelegatorValidatorResponse response type for the Query/DelegatorValidator RPC method." - }, - "v1beta1QueryDelegatorValidatorsResponse": { - "type": "object", - "properties": { - "validators": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1Validator" - }, - "description": "validators defines the the validators' info of a delegator." - }, - "pagination": { - "$ref": "#/definitions/v1beta1PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryDelegatorValidatorsResponse is response type for the Query/DelegatorValidators RPC method." - }, - "v1beta1QueryHistoricalInfoResponse": { - "type": "object", - "properties": { - "hist": { - "$ref": "#/definitions/v1beta1HistoricalInfo", - "description": "hist defines the historical info at the given height." - } - }, - "description": "QueryHistoricalInfoResponse is response type for the Query/HistoricalInfo RPC method." - }, - "v1beta1QueryParamsResponse": { - "type": "object", - "properties": { - "params": { - "$ref": "#/definitions/v1beta1Params", - "description": "params holds all the parameters of this module." - } - }, - "description": "QueryParamsResponse is response type for the Query/Params RPC method." - }, - "v1beta1QueryPoolResponse": { - "type": "object", - "properties": { - "pool": { - "$ref": "#/definitions/v1beta1Pool", - "description": "pool defines the pool info." - } - }, - "description": "QueryPoolResponse is response type for the Query/Pool RPC method." - }, - "v1beta1QueryRedelegationsResponse": { - "type": "object", - "properties": { - "redelegation_responses": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1RedelegationResponse" - } - }, - "pagination": { - "$ref": "#/definitions/v1beta1PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryRedelegationsResponse is response type for the Query/Redelegations RPC method." - }, - "v1beta1QueryUnbondingDelegationResponse": { - "type": "object", - "properties": { - "unbond": { - "$ref": "#/definitions/v1beta1UnbondingDelegation", - "description": "unbond defines the unbonding information of a delegation." - } - }, - "description": "QueryDelegationResponse is response type for the Query/UnbondingDelegation RPC method." - }, - "v1beta1QueryValidatorDelegationsResponse": { - "type": "object", - "properties": { - "delegation_responses": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1DelegationResponse" - } - }, - "pagination": { - "$ref": "#/definitions/v1beta1PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "title": "QueryValidatorDelegationsResponse is response type for the Query/ValidatorDelegations RPC method" - }, - "v1beta1QueryValidatorResponse": { - "type": "object", - "properties": { - "validator": { - "$ref": "#/definitions/v1beta1Validator", - "description": "validator defines the the validator info." - } - }, - "title": "QueryValidatorResponse is response type for the Query/Validator RPC method" - }, - "v1beta1QueryValidatorUnbondingDelegationsResponse": { - "type": "object", - "properties": { - "unbonding_responses": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1UnbondingDelegation" - } - }, - "pagination": { - "$ref": "#/definitions/v1beta1PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryValidatorUnbondingDelegationsResponse is response type for the Query/ValidatorUnbondingDelegations RPC method." - }, - "v1beta1QueryValidatorsResponse": { - "type": "object", - "properties": { - "validators": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1Validator" - }, - "description": "validators contains all the queried validators." - }, - "pagination": { - "$ref": "#/definitions/v1beta1PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "title": "QueryValidatorsResponse is response type for the Query/Validators RPC method" - }, - "v1beta1Redelegation": { - "type": "object", - "properties": { - "delegator_address": { - "type": "string", - "format": "byte" - }, - "validator_src_address": { - "type": "string", - "format": "byte" - }, - "validator_dst_address": { - "type": "string", - "format": "byte" - }, - "entries": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1RedelegationEntry" - } - } - }, - "description": "Redelegation contains the list of a particular delegator's redelegating bonds\nfrom a particular source validator to a particular destination validator." - }, - "v1beta1RedelegationEntry": { - "type": "object", - "properties": { - "creation_height": { - "type": "string", - "format": "int64" - }, - "completion_time": { - "type": "string", - "format": "date-time" - }, - "initial_balance": { - "type": "string" - }, - "shares_dst": { - "type": "string" - } - }, - "description": "RedelegationEntry defines a redelegation object with relevant metadata." - }, - "v1beta1RedelegationEntryResponse": { - "type": "object", - "properties": { - "redelegation_entry": { - "$ref": "#/definitions/v1beta1RedelegationEntry" - }, - "balance": { - "type": "string" - } - }, - "description": "RedelegationEntryResponse is equivalent to a RedelegationEntry except that it\ncontains a balance in addition to shares which is more suitable for client\nresponses." - }, - "v1beta1RedelegationResponse": { - "type": "object", - "properties": { - "redelegation": { - "$ref": "#/definitions/v1beta1Redelegation" - }, - "entries": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1RedelegationEntryResponse" - } - } - }, - "description": "RedelegationResponse is equivalent to a Redelegation except that its entries\ncontain a balance in addition to shares which is more suitable for client\nresponses." - }, - "v1beta1UnbondingDelegation": { - "type": "object", - "properties": { - "delegator_address": { - "type": "string", - "format": "byte" - }, - "validator_address": { - "type": "string", - "format": "byte" - }, - "entries": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1UnbondingDelegationEntry" - } - } - }, - "title": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list" - }, - "v1beta1UnbondingDelegationEntry": { - "type": "object", - "properties": { - "creation_height": { - "type": "string", - "format": "int64" - }, - "completion_time": { - "type": "string", - "format": "date-time" - }, - "initial_balance": { - "type": "string" - }, - "balance": { - "type": "string" - } - }, - "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." - }, - "v1beta1Validator": { - "type": "object", - "properties": { - "operator_address": { - "type": "string", - "format": "byte" - }, - "consensus_pubkey": { - "type": "string" - }, - "jailed": { - "type": "boolean", - "format": "boolean" - }, - "status": { - "type": "integer", - "format": "int32" - }, - "tokens": { - "type": "string" - }, - "delegator_shares": { - "type": "string" - }, - "description": { - "$ref": "#/definitions/v1beta1Description" - }, - "unbonding_height": { - "type": "string", - "format": "int64" - }, - "unbonding_time": { - "type": "string", - "format": "date-time" - }, - "commission": { - "$ref": "#/definitions/v1beta1Commission" - }, - "min_self_delegation": { - "type": "string" - } - }, - "description": "Validator defines the total amount of bond shares and their exchange rate to\ncoins. Slashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." - }, - "versionConsensus": { - "type": "object", - "properties": { - "block": { - "type": "string", - "format": "uint64" - }, - "app": { - "type": "string", - "format": "uint64" - } - }, - "description": "Consensus captures the consensus rules for processing a block in the blockchain,\nincluding all blockchain data structures and the rules of the application's\nstate transition machine." - } - } -} diff --git a/x/upgrade/v1beta1/query.swagger.json b/x/upgrade/v1beta1/query.swagger.json deleted file mode 100644 index 1091f939b017..000000000000 --- a/x/upgrade/v1beta1/query.swagger.json +++ /dev/null @@ -1,150 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "cosmos/upgrade/v1beta1/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/cosmos/upgrade/v1beta1/applied_plan/{name}": { - "get": { - "summary": "AppliedPlan queries a previously applied upgrade plan by its name.", - "operationId": "Query_AppliedPlan", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryAppliedPlanResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "parameters": [ - { - "name": "name", - "description": "name is the name of the applied plan to query for.", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/upgrade/v1beta1/current_plan": { - "get": { - "summary": "CurrentPlan queries the current upgrade plan.", - "operationId": "Query_CurrentPlan", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1QueryCurrentPlanResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - }, - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "protobufAny": { - "type": "object", - "properties": { - "type_url": { - "type": "string" - }, - "value": { - "type": "string", - "format": "byte" - } - } - }, - "runtimeError": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/protobufAny" - } - } - } - }, - "v1beta1Plan": { - "type": "object", - "properties": { - "name": { - "type": "string", - "description": "Sets the name for the upgrade. This name will be used by the upgraded version of the software to apply any\nspecial \"on-upgrade\" commands during the first BeginBlock method after the upgrade is applied. It is also used\nto detect whether a software version can handle a given upgrade. If no upgrade handler with this name has been\nset in the software, it will be assumed that the software is out-of-date when the upgrade Time or Height\nis reached and the software will exit." - }, - "time": { - "type": "string", - "format": "date-time", - "description": "The time after which the upgrade must be performed.\nLeave set to its zero value to use a pre-defined Height instead." - }, - "height": { - "type": "string", - "format": "int64", - "description": "The height at which the upgrade must be performed.\nOnly used if Time is not set." - }, - "info": { - "type": "string", - "title": "Any application specific upgrade info to be included on-chain\nsuch as a git commit that validators could automatically upgrade to" - } - }, - "title": "Plan specifies information about a planned upgrade and when it should occur" - }, - "v1beta1QueryAppliedPlanResponse": { - "type": "object", - "properties": { - "height": { - "type": "string", - "format": "int64", - "description": "height is the block height at which the plan was applied." - } - }, - "description": "QueryAppliedPlanResponse is the response type for the Query/AppliedPlan RPC method." - }, - "v1beta1QueryCurrentPlanResponse": { - "type": "object", - "properties": { - "plan": { - "$ref": "#/definitions/v1beta1Plan", - "description": "plan is the current upgrade plan." - } - }, - "description": "QueryCurrentPlanResponse is the response type for the Query/CurrentPlan RPC method." - } - } -} From 4932f485115d8f00024594ecf1e6a1a37c2a60d6 Mon Sep 17 00:00:00 2001 From: anilCSE Date: Sat, 22 Aug 2020 16:50:41 +0530 Subject: [PATCH 09/27] Fix swagger-combine --- client/grpc-gateway/config.json | 90 + client/grpc-gateway/swagger.json | 9321 +++++++++++++++++ cosmos/auth/v1beta1/query.swagger.json | 155 + cosmos/bank/v1beta1/query.swagger.json | 377 + .../distribution/v1beta1/query.swagger.json | 628 ++ cosmos/evidence/v1beta1/query.swagger.json | 214 + cosmos/gov/v1beta1/query.swagger.json | 785 ++ cosmos/mint/v1beta1/query.swagger.json | 182 + cosmos/params/v1beta1/query.swagger.json | 114 + cosmos/slashing/v1beta1/query.swagger.json | 302 + cosmos/staking/v1beta1/query.swagger.json | 1385 +++ cosmos/upgrade/v1beta1/query.swagger.json | 150 + go.mod | 9 +- go.sum | 178 +- ibc/channel/query.swagger.json | 982 ++ ibc/connection/query.swagger.json | 520 + ibc/transfer/query.swagger.json | 273 + scripts/go-swagger.sh | 8 +- scripts/protocgen.sh | 21 +- 19 files changed, 15504 insertions(+), 190 deletions(-) create mode 100644 client/grpc-gateway/config.json create mode 100644 client/grpc-gateway/swagger.json create mode 100644 cosmos/auth/v1beta1/query.swagger.json create mode 100644 cosmos/bank/v1beta1/query.swagger.json create mode 100644 cosmos/distribution/v1beta1/query.swagger.json create mode 100644 cosmos/evidence/v1beta1/query.swagger.json create mode 100644 cosmos/gov/v1beta1/query.swagger.json create mode 100644 cosmos/mint/v1beta1/query.swagger.json create mode 100644 cosmos/params/v1beta1/query.swagger.json create mode 100644 cosmos/slashing/v1beta1/query.swagger.json create mode 100644 cosmos/staking/v1beta1/query.swagger.json create mode 100644 cosmos/upgrade/v1beta1/query.swagger.json create mode 100644 ibc/channel/query.swagger.json create mode 100644 ibc/connection/query.swagger.json create mode 100644 ibc/transfer/query.swagger.json diff --git a/client/grpc-gateway/config.json b/client/grpc-gateway/config.json new file mode 100644 index 000000000000..428c0379d0b5 --- /dev/null +++ b/client/grpc-gateway/config.json @@ -0,0 +1,90 @@ +{ + "swagger": "2.0", + "info": { + "title": "Basic Swagger Combine Example", + "version": "1.0.0" + }, + "apis": [ + { + "url": "./cosmos/auth/v1beta1/query.swagger.json", + "operationIds": { + "rename": { + "Params": "AuthParams" + } + } + }, + { + "url": "./cosmos/bank/v1beta1/query.swagger.json", + "operationIds": { + "rename": { + "Params": "BankParams" + } + } + }, + { + "url": "./cosmos/distribution/v1beta1/query.swagger.json", + "operationIds": { + "rename": { + "Params": "DistributionParams" + } + } + }, + { + "url": "./cosmos/evidence/v1beta1/query.swagger.json", + "operationIds": { + "rename": { + "Params": "EvidenceParams" + } + } + }, + { + "url": "./cosmos/gov/v1beta1/query.swagger.json", + "operationIds": { + "rename": { + "Params": "GovParams" + } + } + }, + { + "url": "./cosmos/mint/v1beta1/query.swagger.json", + "operationIds": { + "rename": { + "Params": "MintParams" + } + } + }, + { + "url": "./cosmos/params/v1beta1/query.swagger.json", + "operationIds": { + "rename": { + "Params": "Params" + } + } + }, + { + "url": "./cosmos/slashing/v1beta1/query.swagger.json", + "operationIds": { + "rename": { + "Params": "SlashingParams" + } + } + }, + { + "url": "./cosmos/staking/v1beta1/query.swagger.json", + "operationIds": { + "rename": { + "Params": "StakingParams", + "DelegatorValidators": "StakingDelegatorValidators" + } + } + }, + { + "url": "./cosmos/upgrade/v1beta1/query.swagger.json", + "operationIds": { + "rename": { + "Params": "UpgradeParams" + } + } + } + ] +} \ No newline at end of file diff --git a/client/grpc-gateway/swagger.json b/client/grpc-gateway/swagger.json new file mode 100644 index 000000000000..2a17336257d1 --- /dev/null +++ b/client/grpc-gateway/swagger.json @@ -0,0 +1,9321 @@ +{ + "swagger": "2.0", + "info": { + "title": "Basic Swagger Combine Example", + "version": "1.0.0" + }, + "paths": { + "/cosmos/auth/v1beta1/accounts/{address}": { + "get": { + "summary": "Account returns account details based on address.", + "operationId": "Account", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "account": { + "description": "account defines the account of the corresponding address.", + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + } + } + }, + "description": "QueryAccountResponse is the response type for the Query/Account RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "address", + "description": "address defines the address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/auth/v1beta1/params": { + "get": { + "summary": "Params queries all parameters.", + "operationId": "AuthParams", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "params": { + "description": "params defines the parameters of the module.", + "type": "object", + "properties": { + "max_memo_characters": { + "type": "string", + "format": "uint64" + }, + "tx_sig_limit": { + "type": "string", + "format": "uint64" + }, + "tx_size_cost_per_byte": { + "type": "string", + "format": "uint64" + }, + "sig_verify_cost_ed25519": { + "type": "string", + "format": "uint64" + }, + "sig_verify_cost_secp256k1": { + "type": "string", + "format": "uint64" + } + } + } + }, + "description": "QueryParamsResponse is the response type for the Query/Params RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/bank/v1beta1/balances/{address}": { + "get": { + "summary": "AllBalances queries the balance of all coins for a single account.", + "operationId": "AllBalances", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "balances": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + }, + "description": "balances is the balances of all the coins." + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "description": "QueryAllBalancesResponse is the response type for the Query/AllBalances RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "address", + "description": "address is the address to query balances for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/bank/v1beta1/balances/{address}/{denom}": { + "get": { + "summary": "Balance queries the balance of a single coin for a single account.", + "operationId": "Balance", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "balance": { + "description": "balance is the balance of the coin.", + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + } + } + }, + "description": "QueryBalanceResponse is the response type for the Query/Balance RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "address", + "description": "address is the address to query balances for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "denom", + "description": "denom is the coin denom to query balances for.", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/bank/v1beta1/params": { + "get": { + "summary": "Params queries the parameters of x/bank module.", + "operationId": "BankParams", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "params": { + "type": "object", + "properties": { + "send_enabled": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "enabled": { + "type": "boolean", + "format": "boolean" + } + }, + "title": "Send enabled configuration properties for each denomination" + } + }, + "default_send_enabled": { + "type": "boolean", + "format": "boolean" + } + }, + "description": "Params defines the set of bank parameters." + } + }, + "description": "QueryParamsResponse defines the response type for querying x/bank parameters." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/bank/v1beta1/supply": { + "get": { + "summary": "TotalSupply queries the total supply of all coins.", + "operationId": "TotalSupply", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "supply": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + }, + "title": "supply is the supply of the coins" + } + }, + "title": "QueryTotalSupplyResponse is the response type for the Query/TotalSupply RPC method" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/bank/v1beta1/supply/{denom}": { + "get": { + "summary": "SupplyOf queries the supply of a single coin.", + "operationId": "SupplyOf", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "amount": { + "description": "amount is the supply of the coin.", + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + } + } + }, + "description": "QuerySupplyOfResponse is the response type for the Query/SupplyOf RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "denom", + "description": "denom is the coin denom to query balances for.", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/community_pool": { + "get": { + "summary": "CommunityPool queries the community pool coins.", + "operationId": "CommunityPool", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "pool": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "DecCoin defines a token with a denomination and a decimal amount.\n\nNOTE: The amount field is an Dec which implements the custom method\nsignatures required by gogoproto." + }, + "description": "pool defines community pool's coins." + } + }, + "description": "QueryCommunityPoolResponse is the response type for the Query/CommunityPool RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards": { + "get": { + "summary": "DelegationTotalRewards queries the total rewards accrued by a each validator.", + "operationId": "DelegationTotalRewards", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "rewards": { + "type": "array", + "items": { + "type": "object", + "properties": { + "validator_address": { + "type": "string", + "format": "byte" + }, + "reward": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "DecCoin defines a token with a denomination and a decimal amount.\n\nNOTE: The amount field is an Dec which implements the custom method\nsignatures required by gogoproto." + } + } + }, + "description": "DelegationDelegatorReward defines the properties\nof a delegator's delegation reward." + }, + "description": "rewards defines all the rewards accrued by a delegator." + }, + "total": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "DecCoin defines a token with a denomination and a decimal amount.\n\nNOTE: The amount field is an Dec which implements the custom method\nsignatures required by gogoproto." + }, + "description": "total defines the sum of all the rewards." + } + }, + "description": "QueryDelegationTotalRewardsResponse is the response type for the Query/DelegationTotalRewards RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "delegator_address", + "description": "delegator_address defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards/{validator_address}": { + "get": { + "summary": "DelegationRewards queries the total rewards accrued by a delegation.", + "operationId": "DelegationRewards", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "rewards": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "DecCoin defines a token with a denomination and a decimal amount.\n\nNOTE: The amount field is an Dec which implements the custom method\nsignatures required by gogoproto." + }, + "description": "rewards defines the rewards accrued by a delegation." + } + }, + "description": "QueryDelegationRewardsResponse is the response type for the Query/DelegationRewards RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "delegator_address", + "description": "delegator_address defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "validator_address", + "description": "validator_address defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/delegators/{delegator_address}/validators": { + "get": { + "summary": "DelegatorValidators queries the validators of a delegator.", + "operationId": "DelegatorValidators", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "validators": { + "type": "array", + "items": { + "type": "string", + "format": "byte" + }, + "description": "validators defines the validators a delegator is delegating for." + } + }, + "description": "QueryDelegatorValidatorsResponse is the response type for the Query/DelegatorValidators RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "delegator_address", + "description": "delegator_address defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/delegators/{delegator_address}/withdraw_address": { + "get": { + "summary": "DelegatorWithdrawAddress queries withdraw address of a delegator.", + "operationId": "DelegatorWithdrawAddress", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "withdraw_address": { + "type": "string", + "format": "byte", + "description": "withdraw_address defines the delegator address to query for." + } + }, + "description": "QueryDelegatorWithdrawAddressResponse is the response type for the Query/DelegatorWithdrawAddress RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "delegator_address", + "description": "delegator_address defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/params": { + "get": { + "summary": "Params queries params of the distribution module.", + "operationId": "DistributionParams", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "params": { + "description": "params defines the parameters of the module.", + "type": "object", + "properties": { + "community_tax": { + "type": "string" + }, + "base_proposer_reward": { + "type": "string" + }, + "bonus_proposer_reward": { + "type": "string" + }, + "withdraw_addr_enabled": { + "type": "boolean", + "format": "boolean" + } + } + } + }, + "description": "QueryParamsResponse is the response type for the Query/Params RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/validators/{validator_address}/commission": { + "get": { + "summary": "ValidatorCommission queries accumulated commission for a validator.", + "operationId": "ValidatorCommission", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "commission": { + "description": "commission defines the commision the validator received.", + "type": "object", + "properties": { + "commission": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "DecCoin defines a token with a denomination and a decimal amount.\n\nNOTE: The amount field is an Dec which implements the custom method\nsignatures required by gogoproto." + } + } + }, + "title": "accumulated commission for a validator\nkept as a running counter, can be withdrawn at any time" + } + }, + "title": "QueryValidatorCommissionResponse is the response type for the Query/ValidatorCommission RPC method" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "validator_address", + "description": "validator_address defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/validators/{validator_address}/outstanding_rewards": { + "get": { + "summary": "ValidatorOutstandingRewards queries rewards of a validator address.", + "operationId": "ValidatorOutstandingRewards", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "rewards": { + "type": "object", + "properties": { + "rewards": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "DecCoin defines a token with a denomination and a decimal amount.\n\nNOTE: The amount field is an Dec which implements the custom method\nsignatures required by gogoproto." + } + } + }, + "title": "outstanding (un-withdrawn) rewards for a validator\ninexpensive to track, allows simple sanity checks" + } + }, + "description": "QueryValidatorOutstandingRewardsResponse is the response type for the Query/ValidatorOutstandingRewards RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "validator_address", + "description": "validator_address defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/validators/{validator_address}/slashes": { + "get": { + "summary": "ValidatorSlashes queries slash events of a validator.", + "operationId": "ValidatorSlashes", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "slashes": { + "type": "array", + "items": { + "type": "object", + "properties": { + "validator_period": { + "type": "string", + "format": "uint64" + }, + "fraction": { + "type": "string" + } + }, + "title": "validator slash event\nheight is implicit within the store key\nneeded to calculate appropriate amounts of staking token\nfor delegations which withdraw after a slash has occurred" + }, + "description": "slashes defines the slashes the validator received." + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "description": "QueryValidatorSlashesResponse is the response type for the Query/ValidatorSlashes RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "validator_address", + "description": "validator_address defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "starting_height", + "description": "starting_height defines the optional starting height to query the slashes.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "ending_height", + "description": "starting_height defines the optional ending height to query the slashes.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/evidence/v1beta1/evidence": { + "get": { + "summary": "AllEvidence queries all evidence.", + "operationId": "AllEvidence", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "evidence": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "description": "evidence returns all evidences." + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "description": "QueryAllEvidenceResponse is the response type for the Query/AllEvidence RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/evidence/v1beta1/evidence/{evidence_hash}": { + "get": { + "summary": "Evidence queries evidence based on evidence hash.", + "operationId": "Evidence", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "evidence": { + "description": "evidence returns the requested evidence.", + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + } + } + }, + "description": "QueryEvidenceResponse is the response type for the Query/Evidence RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "evidence_hash", + "description": "evidence_hash defines the hash of the requested evidence.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/gov/v1beta1/params/{params_type}": { + "get": { + "summary": "Params queries all parameters of the gov module.", + "operationId": "GovParams", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "voting_params": { + "description": "voting_params defines the parameters related to voting.", + "type": "object", + "properties": { + "voting_period": { + "type": "string", + "description": "Length of the voting period." + } + }, + "title": "VotingParams defines the params around Voting in governance" + }, + "deposit_params": { + "description": "deposit_params defines the parameters related to deposit.", + "type": "object", + "properties": { + "min_deposit": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + }, + "description": "Minimum deposit for a proposal to enter voting period." + }, + "max_deposit_period": { + "type": "string", + "description": "Maximum period for Atom holders to deposit on a proposal. Initial value: 2 months." + } + }, + "title": "DepositParams defines the params around deposits for governance" + }, + "tally_params": { + "description": "tally_params defines the parameters related to tally.", + "type": "object", + "properties": { + "quorum": { + "type": "string", + "format": "byte", + "description": "Minimum percentage of total stake needed to vote for a result to be considered valid." + }, + "threshold": { + "type": "string", + "format": "byte", + "description": "Minimum proportion of Yes votes for proposal to pass. Initial value: 0.5." + }, + "veto": { + "type": "string", + "format": "byte", + "description": "Minimum value of Veto votes to Total votes ratio for proposal to be vetoed. Initial value: 1/3." + } + }, + "title": "TallyParams defines the params around Tallying votes in governance" + } + }, + "description": "QueryParamsResponse is the response type for the Query/Params RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "params_type", + "description": "params_type defines which parameters to query for, can be one of \"voting\", \"tallying\" or \"deposit\".", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/gov/v1beta1/proposals": { + "get": { + "summary": "Proposals queries all proposals based on given status.", + "operationId": "Proposals", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "proposals": { + "type": "array", + "items": { + "type": "object", + "properties": { + "proposal_id": { + "type": "string", + "format": "uint64" + }, + "content": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "status": { + "type": "string", + "enum": [ + "PROPOSAL_STATUS_UNSPECIFIED", + "PROPOSAL_STATUS_DEPOSIT_PERIOD", + "PROPOSAL_STATUS_VOTING_PERIOD", + "PROPOSAL_STATUS_PASSED", + "PROPOSAL_STATUS_REJECTED", + "PROPOSAL_STATUS_FAILED" + ], + "default": "PROPOSAL_STATUS_UNSPECIFIED", + "description": "- PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed.", + "title": "ProposalStatus is a type alias that represents a proposal status as a byte" + }, + "final_tally_result": { + "type": "object", + "properties": { + "yes": { + "type": "string" + }, + "abstain": { + "type": "string" + }, + "no": { + "type": "string" + }, + "no_with_veto": { + "type": "string" + } + }, + "title": "TallyResult defines a standard tally for a proposal" + }, + "submit_time": { + "type": "string", + "format": "date-time" + }, + "deposit_end_time": { + "type": "string", + "format": "date-time" + }, + "total_deposit": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + } + }, + "voting_start_time": { + "type": "string", + "format": "date-time" + }, + "voting_end_time": { + "type": "string", + "format": "date-time" + } + }, + "title": "Proposal defines the core field members of a governance proposal" + } + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "description": "QueryProposalsResponse is the response type for the Query/Proposals RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "proposal_status", + "description": "proposal_status defines the status of the proposals.\n\n - PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed.", + "in": "query", + "required": false, + "type": "string", + "enum": [ + "PROPOSAL_STATUS_UNSPECIFIED", + "PROPOSAL_STATUS_DEPOSIT_PERIOD", + "PROPOSAL_STATUS_VOTING_PERIOD", + "PROPOSAL_STATUS_PASSED", + "PROPOSAL_STATUS_REJECTED", + "PROPOSAL_STATUS_FAILED" + ], + "default": "PROPOSAL_STATUS_UNSPECIFIED" + }, + { + "name": "voter", + "description": "voter defines the voter address for the proposals.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "depositor", + "description": "depositor defines the deposit addresses from the proposals.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/gov/v1beta1/proposals/{proposal_id}": { + "get": { + "summary": "Proposal queries proposal details based on ProposalID.", + "operationId": "Proposal", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "proposal": { + "type": "object", + "properties": { + "proposal_id": { + "type": "string", + "format": "uint64" + }, + "content": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "status": { + "type": "string", + "enum": [ + "PROPOSAL_STATUS_UNSPECIFIED", + "PROPOSAL_STATUS_DEPOSIT_PERIOD", + "PROPOSAL_STATUS_VOTING_PERIOD", + "PROPOSAL_STATUS_PASSED", + "PROPOSAL_STATUS_REJECTED", + "PROPOSAL_STATUS_FAILED" + ], + "default": "PROPOSAL_STATUS_UNSPECIFIED", + "description": "- PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed.", + "title": "ProposalStatus is a type alias that represents a proposal status as a byte" + }, + "final_tally_result": { + "type": "object", + "properties": { + "yes": { + "type": "string" + }, + "abstain": { + "type": "string" + }, + "no": { + "type": "string" + }, + "no_with_veto": { + "type": "string" + } + }, + "title": "TallyResult defines a standard tally for a proposal" + }, + "submit_time": { + "type": "string", + "format": "date-time" + }, + "deposit_end_time": { + "type": "string", + "format": "date-time" + }, + "total_deposit": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + } + }, + "voting_start_time": { + "type": "string", + "format": "date-time" + }, + "voting_end_time": { + "type": "string", + "format": "date-time" + } + }, + "title": "Proposal defines the core field members of a governance proposal" + } + }, + "description": "QueryProposalResponse is the response type for the Query/Proposal RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "proposal_id", + "description": "proposal_id defines the unique id of the proposal.", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/gov/v1beta1/proposals/{proposal_id}/deposits": { + "get": { + "summary": "Deposits queries all deposits of a single proposal.", + "operationId": "Deposits", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "deposits": { + "type": "array", + "items": { + "type": "object", + "properties": { + "proposal_id": { + "type": "string", + "format": "uint64" + }, + "depositor": { + "type": "string", + "format": "byte" + }, + "amount": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + } + } + }, + "title": "Deposit defines an amount deposited by an account address to an active proposal" + } + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "description": "QueryDepositsResponse is the response type for the Query/Deposits RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "proposal_id", + "description": "proposal_id defines the unique id of the proposal.", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/gov/v1beta1/proposals/{proposal_id}/deposits/{depositor}": { + "get": { + "summary": "Deposit queries single deposit information based proposalID, depositAddr.", + "operationId": "Deposit", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "deposit": { + "description": "deposit defines the requested deposit.", + "type": "object", + "properties": { + "proposal_id": { + "type": "string", + "format": "uint64" + }, + "depositor": { + "type": "string", + "format": "byte" + }, + "amount": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + } + } + }, + "title": "Deposit defines an amount deposited by an account address to an active proposal" + } + }, + "description": "QueryDepositResponse is the response type for the Query/Deposit RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "proposal_id", + "description": "proposal_id defines the unique id of the proposal.", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + }, + { + "name": "depositor", + "description": "depositor defines the deposit addresses from the proposals.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/gov/v1beta1/proposals/{proposal_id}/tally": { + "get": { + "summary": "TallyResult queries the tally of a proposal vote.", + "operationId": "TallyResult", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "tally": { + "description": "tally defines the requested tally.", + "type": "object", + "properties": { + "yes": { + "type": "string" + }, + "abstain": { + "type": "string" + }, + "no": { + "type": "string" + }, + "no_with_veto": { + "type": "string" + } + }, + "title": "TallyResult defines a standard tally for a proposal" + } + }, + "description": "QueryTallyResultResponse is the response type for the Query/Tally RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "proposal_id", + "description": "proposal_id defines the unique id of the proposal.", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/gov/v1beta1/proposals/{proposal_id}/votes": { + "get": { + "summary": "Votes queries votes of a given proposal.", + "operationId": "Votes", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "votes": { + "type": "array", + "items": { + "type": "object", + "properties": { + "proposal_id": { + "type": "string", + "format": "uint64" + }, + "voter": { + "type": "string", + "format": "byte" + }, + "option": { + "type": "string", + "enum": [ + "VOTE_OPTION_UNSPECIFIED", + "VOTE_OPTION_YES", + "VOTE_OPTION_ABSTAIN", + "VOTE_OPTION_NO", + "VOTE_OPTION_NO_WITH_VETO" + ], + "default": "VOTE_OPTION_UNSPECIFIED", + "description": "- VOTE_OPTION_UNSPECIFIED: VOTE_OPTION_UNSPECIFIED defines a no-op vote option.\n - VOTE_OPTION_YES: VOTE_OPTION_YES defines a yes vote option.\n - VOTE_OPTION_ABSTAIN: VOTE_OPTION_ABSTAIN defines an abstain vote option.\n - VOTE_OPTION_NO: VOTE_OPTION_NO defines a no vote option.\n - VOTE_OPTION_NO_WITH_VETO: VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option.", + "title": "VoteOption defines a vote option" + } + }, + "description": "Vote defines a vote on a governance proposal. A vote corresponds to a proposal\nID, the voter, and the vote option." + }, + "description": "votes defined the queried votes." + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "description": "QueryVotesResponse is the response type for the Query/Votes RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "proposal_id", + "description": "proposal_id defines the unique id of the proposal.", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/gov/v1beta1/proposals/{proposal_id}/votes/{voter}": { + "get": { + "summary": "Vote queries voted information based on proposalID, voterAddr.", + "operationId": "Vote", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "vote": { + "description": "vote defined the queried vote.", + "type": "object", + "properties": { + "proposal_id": { + "type": "string", + "format": "uint64" + }, + "voter": { + "type": "string", + "format": "byte" + }, + "option": { + "type": "string", + "enum": [ + "VOTE_OPTION_UNSPECIFIED", + "VOTE_OPTION_YES", + "VOTE_OPTION_ABSTAIN", + "VOTE_OPTION_NO", + "VOTE_OPTION_NO_WITH_VETO" + ], + "default": "VOTE_OPTION_UNSPECIFIED", + "description": "- VOTE_OPTION_UNSPECIFIED: VOTE_OPTION_UNSPECIFIED defines a no-op vote option.\n - VOTE_OPTION_YES: VOTE_OPTION_YES defines a yes vote option.\n - VOTE_OPTION_ABSTAIN: VOTE_OPTION_ABSTAIN defines an abstain vote option.\n - VOTE_OPTION_NO: VOTE_OPTION_NO defines a no vote option.\n - VOTE_OPTION_NO_WITH_VETO: VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option.", + "title": "VoteOption defines a vote option" + } + } + } + }, + "description": "QueryVoteResponse is the response type for the Query/Vote RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "proposal_id", + "description": "proposal_id defines the unique id of the proposal.", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + }, + { + "name": "voter", + "description": "voter defines the oter address for the proposals.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/mint/v1beta1/annual_provisions": { + "get": { + "summary": "AnnualProvisions current minting annual provisions value.", + "operationId": "AnnualProvisions", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "annual_provisions": { + "type": "string", + "format": "byte", + "description": "annual_provisions is the current minting annual provisions value." + } + }, + "description": "QueryAnnualProvisionsResponse is the response type for the Query/AnnualProvisions RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/mint/v1beta1/inflation": { + "get": { + "summary": "Inflation returns the current minting inflation value.", + "operationId": "Inflation", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "inflation": { + "type": "string", + "format": "byte", + "description": "inflation is the current minting inflation value." + } + }, + "description": "QueryInflationResponse is the response type for the Query/Inflation RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/mint/v1beta1/params": { + "get": { + "summary": "Params returns the total set of minting parameters.", + "operationId": "MintParams", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "params": { + "description": "params defines the parameters of the module.", + "type": "object", + "properties": { + "mint_denom": { + "type": "string", + "title": "type of coin to mint" + }, + "inflation_rate_change": { + "type": "string", + "title": "maximum annual change in inflation rate" + }, + "inflation_max": { + "type": "string", + "title": "maximum inflation rate" + }, + "inflation_min": { + "type": "string", + "title": "minimum inflation rate" + }, + "goal_bonded": { + "type": "string", + "title": "goal of percent bonded atoms" + }, + "blocks_per_year": { + "type": "string", + "format": "uint64", + "title": "expected blocks per year" + } + }, + "title": "mint parameters" + } + }, + "description": "QueryParamsResponse is the response type for the Query/Params RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/params/v1beta1/params": { + "get": { + "summary": "Params queries a specific parameter of a module, given its subspace and key.", + "operationId": "Params", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "param": { + "description": "param defines the queried parameter.", + "type": "object", + "properties": { + "subspace": { + "type": "string" + }, + "key": { + "type": "string" + }, + "value": { + "type": "string" + } + } + } + }, + "description": "QueryParamsResponse is response type for the Query/Params RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "subspace", + "description": "subspace defines the module to query the parameter for.", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "key", + "description": "key defines the key of the parameter in the subspace.", + "in": "query", + "required": false, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/slashing/v1beta1/params": { + "get": { + "summary": "Params queries the parameters of slashing module", + "operationId": "SlashingParams", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "params": { + "type": "object", + "properties": { + "signed_blocks_window": { + "type": "string", + "format": "int64" + }, + "min_signed_per_window": { + "type": "string", + "format": "byte" + }, + "downtime_jail_duration": { + "type": "string" + }, + "slash_fraction_double_sign": { + "type": "string", + "format": "byte" + }, + "slash_fraction_downtime": { + "type": "string", + "format": "byte" + } + }, + "title": "Params - used for initializing default parameter for slashing at genesis" + } + }, + "title": "QueryParamsResponse is the response type for the Query/Params RPC method" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/slashing/v1beta1/signing_infos": { + "get": { + "summary": "SigningInfos queries signing info of all validators", + "operationId": "SigningInfos", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "info": { + "type": "array", + "items": { + "type": "object", + "properties": { + "address": { + "type": "string", + "format": "byte" + }, + "start_height": { + "type": "string", + "format": "int64", + "title": "height at which validator was first a candidate OR was unjailed" + }, + "index_offset": { + "type": "string", + "format": "int64", + "title": "index offset into signed block bit array" + }, + "jailed_until": { + "type": "string", + "format": "date-time", + "title": "timestamp validator cannot be unjailed until" + }, + "tombstoned": { + "type": "boolean", + "format": "boolean", + "title": "whether or not a validator has been tombstoned (killed out of validator set)" + }, + "missed_blocks_counter": { + "type": "string", + "format": "int64", + "title": "missed blocks counter (to avoid scanning the array every time)" + } + }, + "title": "ValidatorSigningInfo defines the signing info for a validator" + }, + "title": "info is the signing info of all validators" + }, + "pagination": { + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "title": "QuerySigningInfosResponse is the response type for the Query/SigningInfos RPC method" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/slashing/v1beta1/signing_infos/{cons_address}": { + "get": { + "summary": "SigningInfo queries the signing info of given cons address", + "operationId": "SigningInfo", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "val_signing_info": { + "title": "val_signing_info is the signing info of requested val cons address", + "type": "object", + "properties": { + "address": { + "type": "string", + "format": "byte" + }, + "start_height": { + "type": "string", + "format": "int64", + "title": "height at which validator was first a candidate OR was unjailed" + }, + "index_offset": { + "type": "string", + "format": "int64", + "title": "index offset into signed block bit array" + }, + "jailed_until": { + "type": "string", + "format": "date-time", + "title": "timestamp validator cannot be unjailed until" + }, + "tombstoned": { + "type": "boolean", + "format": "boolean", + "title": "whether or not a validator has been tombstoned (killed out of validator set)" + }, + "missed_blocks_counter": { + "type": "string", + "format": "int64", + "title": "missed blocks counter (to avoid scanning the array every time)" + } + } + } + }, + "title": "QuerySigningInfoResponse is the response type for the Query/SigningInfo RPC method" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "cons_address", + "description": "cons_address is the address to query signing info of", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/delegations/{delegator_addr}": { + "get": { + "summary": "DelegatorDelegations queries all delegations of a given delegator address.", + "operationId": "DelegatorDelegations", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "delegation_responses": { + "type": "array", + "items": { + "type": "object", + "properties": { + "delegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "shares": { + "type": "string" + } + }, + "description": "Delegation represents the bond with tokens held by an account. It is\nowned by one delegator, and is associated with the voting power of one\nvalidator." + }, + "balance": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + } + }, + "description": "DelegationResponse is equivalent to Delegation except that it contains a balance\nin addition to shares which is more suitable for client responses." + }, + "description": "delegation_responses defines all the delegations' info of a delegator." + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "description": "QueryDelegatorDelegationsResponse is response type for the Query/DelegatorDelegations RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "delegator_addr", + "description": "delegator_addr defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/delegators/{delegator_addr}/redelegations": { + "get": { + "summary": "Redelegations queries redelegations of given address.", + "operationId": "Redelegations", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "redelegation_responses": { + "type": "array", + "items": { + "type": "object", + "properties": { + "redelegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_src_address": { + "type": "string", + "format": "byte" + }, + "validator_dst_address": { + "type": "string", + "format": "byte" + }, + "entries": { + "type": "array", + "items": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "shares_dst": { + "type": "string" + } + }, + "description": "RedelegationEntry defines a redelegation object with relevant metadata." + } + } + }, + "description": "Redelegation contains the list of a particular delegator's redelegating bonds\nfrom a particular source validator to a particular destination validator." + }, + "entries": { + "type": "array", + "items": { + "type": "object", + "properties": { + "redelegation_entry": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "shares_dst": { + "type": "string" + } + }, + "description": "RedelegationEntry defines a redelegation object with relevant metadata." + }, + "balance": { + "type": "string" + } + }, + "description": "RedelegationEntryResponse is equivalent to a RedelegationEntry except that it\ncontains a balance in addition to shares which is more suitable for client\nresponses." + } + } + }, + "description": "RedelegationResponse is equivalent to a Redelegation except that its entries\ncontain a balance in addition to shares which is more suitable for client\nresponses." + } + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "description": "QueryRedelegationsResponse is response type for the Query/Redelegations RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "delegator_addr", + "description": "delegator_addr defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "src_validator_addr", + "description": "src_validator_addr defines the validator address to redelegate from.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "dst_validator_addr", + "description": "dst_validator_addr defines the validator address to redelegate to.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/delegators/{delegator_addr}/unbonding_delegations": { + "get": { + "summary": "DelegatorUnbondingDelegations queries all unbonding delegations of a given delegator address.", + "operationId": "DelegatorUnbondingDelegations", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "unbonding_responses": { + "type": "array", + "items": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "entries": { + "type": "array", + "items": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "balance": { + "type": "string" + } + }, + "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." + } + } + }, + "title": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list" + } + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "description": "QueryUnbondingDelegatorDelegationsResponse is response type for the Query/UnbondingDelegatorDelegations RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "delegator_addr", + "description": "delegator_addr defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators": { + "get": { + "summary": "DelegatorValidators queries all validators info for given delegator address.", + "operationId": "StakingDelegatorValidators", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "validators": { + "type": "array", + "items": { + "type": "object", + "properties": { + "operator_address": { + "type": "string", + "format": "byte" + }, + "consensus_pubkey": { + "type": "string" + }, + "jailed": { + "type": "boolean", + "format": "boolean" + }, + "status": { + "type": "integer", + "format": "int32" + }, + "tokens": { + "type": "string" + }, + "delegator_shares": { + "type": "string" + }, + "description": { + "type": "object", + "properties": { + "moniker": { + "type": "string" + }, + "identity": { + "type": "string" + }, + "website": { + "type": "string" + }, + "security_contact": { + "type": "string" + }, + "details": { + "type": "string" + } + }, + "description": "Description defines a validator description." + }, + "unbonding_height": { + "type": "string", + "format": "int64" + }, + "unbonding_time": { + "type": "string", + "format": "date-time" + }, + "commission": { + "type": "object", + "properties": { + "commission_rates": { + "type": "object", + "properties": { + "rate": { + "type": "string" + }, + "max_rate": { + "type": "string" + }, + "max_change_rate": { + "type": "string" + } + }, + "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + }, + "update_time": { + "type": "string", + "format": "date-time" + } + }, + "description": "Commission defines a commission parameters for a given validator." + }, + "min_self_delegation": { + "type": "string" + } + }, + "description": "Validator defines the total amount of bond shares and their exchange rate to\ncoins. Slashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." + }, + "description": "validators defines the the validators' info of a delegator." + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "description": "QueryDelegatorValidatorsResponse is response type for the Query/DelegatorValidators RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "delegator_addr", + "description": "delegator_addr defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators/{validator_addr}": { + "get": { + "summary": "DelegatorValidator queries validator info for given delegator validator pair.", + "operationId": "DelegatorValidator", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "validator": { + "description": "validator defines the the validator info.", + "type": "object", + "properties": { + "operator_address": { + "type": "string", + "format": "byte" + }, + "consensus_pubkey": { + "type": "string" + }, + "jailed": { + "type": "boolean", + "format": "boolean" + }, + "status": { + "type": "integer", + "format": "int32" + }, + "tokens": { + "type": "string" + }, + "delegator_shares": { + "type": "string" + }, + "description": { + "type": "object", + "properties": { + "moniker": { + "type": "string" + }, + "identity": { + "type": "string" + }, + "website": { + "type": "string" + }, + "security_contact": { + "type": "string" + }, + "details": { + "type": "string" + } + }, + "description": "Description defines a validator description." + }, + "unbonding_height": { + "type": "string", + "format": "int64" + }, + "unbonding_time": { + "type": "string", + "format": "date-time" + }, + "commission": { + "type": "object", + "properties": { + "commission_rates": { + "type": "object", + "properties": { + "rate": { + "type": "string" + }, + "max_rate": { + "type": "string" + }, + "max_change_rate": { + "type": "string" + } + }, + "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + }, + "update_time": { + "type": "string", + "format": "date-time" + } + }, + "description": "Commission defines a commission parameters for a given validator." + }, + "min_self_delegation": { + "type": "string" + } + } + } + }, + "description": "QueryDelegatorValidatorResponse response type for the Query/DelegatorValidator RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "delegator_addr", + "description": "delegator_addr defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "validator_addr", + "description": "validator_addr defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/historical_info/{height}": { + "get": { + "summary": "HistoricalInfo queries the historical info for given height.", + "operationId": "HistoricalInfo", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "hist": { + "description": "hist defines the historical info at the given height.", + "type": "object", + "properties": { + "header": { + "type": "object", + "properties": { + "version": { + "title": "basic block info", + "type": "object", + "properties": { + "block": { + "type": "string", + "format": "uint64" + }, + "app": { + "type": "string", + "format": "uint64" + } + }, + "description": "Consensus captures the consensus rules for processing a block in the blockchain,\nincluding all blockchain data structures and the rules of the application's\nstate transition machine." + }, + "chain_id": { + "type": "string" + }, + "height": { + "type": "string", + "format": "int64" + }, + "time": { + "type": "string", + "format": "date-time" + }, + "last_block_id": { + "title": "prev block info", + "type": "object", + "properties": { + "hash": { + "type": "string", + "format": "byte" + }, + "part_set_header": { + "type": "object", + "properties": { + "total": { + "type": "integer", + "format": "int64" + }, + "hash": { + "type": "string", + "format": "byte" + } + }, + "title": "PartsetHeader" + } + } + }, + "last_commit_hash": { + "type": "string", + "format": "byte", + "title": "hashes of block data" + }, + "data_hash": { + "type": "string", + "format": "byte" + }, + "validators_hash": { + "type": "string", + "format": "byte", + "title": "hashes from the app output from the prev block" + }, + "next_validators_hash": { + "type": "string", + "format": "byte" + }, + "consensus_hash": { + "type": "string", + "format": "byte" + }, + "app_hash": { + "type": "string", + "format": "byte" + }, + "last_results_hash": { + "type": "string", + "format": "byte" + }, + "evidence_hash": { + "type": "string", + "format": "byte", + "title": "consensus info" + }, + "proposer_address": { + "type": "string", + "format": "byte" + } + }, + "description": "Header defines the structure of a Tendermint block header." + }, + "valset": { + "type": "array", + "items": { + "type": "object", + "properties": { + "operator_address": { + "type": "string", + "format": "byte" + }, + "consensus_pubkey": { + "type": "string" + }, + "jailed": { + "type": "boolean", + "format": "boolean" + }, + "status": { + "type": "integer", + "format": "int32" + }, + "tokens": { + "type": "string" + }, + "delegator_shares": { + "type": "string" + }, + "description": { + "type": "object", + "properties": { + "moniker": { + "type": "string" + }, + "identity": { + "type": "string" + }, + "website": { + "type": "string" + }, + "security_contact": { + "type": "string" + }, + "details": { + "type": "string" + } + }, + "description": "Description defines a validator description." + }, + "unbonding_height": { + "type": "string", + "format": "int64" + }, + "unbonding_time": { + "type": "string", + "format": "date-time" + }, + "commission": { + "type": "object", + "properties": { + "commission_rates": { + "type": "object", + "properties": { + "rate": { + "type": "string" + }, + "max_rate": { + "type": "string" + }, + "max_change_rate": { + "type": "string" + } + }, + "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + }, + "update_time": { + "type": "string", + "format": "date-time" + } + }, + "description": "Commission defines a commission parameters for a given validator." + }, + "min_self_delegation": { + "type": "string" + } + }, + "description": "Validator defines the total amount of bond shares and their exchange rate to\ncoins. Slashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." + } + } + } + } + }, + "description": "QueryHistoricalInfoResponse is response type for the Query/HistoricalInfo RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "height", + "description": "height defines at which height to query the historical info.", + "in": "path", + "required": true, + "type": "string", + "format": "int64" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/params": { + "get": { + "summary": "Parameters queries the staking parameters.", + "operationId": "StakingParams", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "params": { + "description": "params holds all the parameters of this module.", + "type": "object", + "properties": { + "unbonding_time": { + "type": "string" + }, + "max_validators": { + "type": "integer", + "format": "int64" + }, + "max_entries": { + "type": "integer", + "format": "int64" + }, + "historical_entries": { + "type": "integer", + "format": "int64" + }, + "bond_denom": { + "type": "string" + } + } + } + }, + "description": "QueryParamsResponse is response type for the Query/Params RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/pool": { + "get": { + "summary": "Pool queries the pool info.", + "operationId": "Pool", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "pool": { + "description": "pool defines the pool info.", + "type": "object", + "properties": { + "not_bonded_tokens": { + "type": "string" + }, + "bonded_tokens": { + "type": "string" + } + }, + "title": "Pool - tracking bonded and not-bonded token supply of the bond denomination" + } + }, + "description": "QueryPoolResponse is response type for the Query/Pool RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/validators": { + "get": { + "summary": "Validators queries all validators that match the given status.", + "operationId": "Validators", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "validators": { + "type": "array", + "items": { + "type": "object", + "properties": { + "operator_address": { + "type": "string", + "format": "byte" + }, + "consensus_pubkey": { + "type": "string" + }, + "jailed": { + "type": "boolean", + "format": "boolean" + }, + "status": { + "type": "integer", + "format": "int32" + }, + "tokens": { + "type": "string" + }, + "delegator_shares": { + "type": "string" + }, + "description": { + "type": "object", + "properties": { + "moniker": { + "type": "string" + }, + "identity": { + "type": "string" + }, + "website": { + "type": "string" + }, + "security_contact": { + "type": "string" + }, + "details": { + "type": "string" + } + }, + "description": "Description defines a validator description." + }, + "unbonding_height": { + "type": "string", + "format": "int64" + }, + "unbonding_time": { + "type": "string", + "format": "date-time" + }, + "commission": { + "type": "object", + "properties": { + "commission_rates": { + "type": "object", + "properties": { + "rate": { + "type": "string" + }, + "max_rate": { + "type": "string" + }, + "max_change_rate": { + "type": "string" + } + }, + "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + }, + "update_time": { + "type": "string", + "format": "date-time" + } + }, + "description": "Commission defines a commission parameters for a given validator." + }, + "min_self_delegation": { + "type": "string" + } + }, + "description": "Validator defines the total amount of bond shares and their exchange rate to\ncoins. Slashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." + }, + "description": "validators contains all the queried validators." + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "title": "QueryValidatorsResponse is response type for the Query/Validators RPC method" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "status", + "description": "status enables to query for validators matching a given status.", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/validators/{validator_addr}": { + "get": { + "summary": "Validator queries validator info for given validator address.", + "operationId": "Validator", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "validator": { + "description": "validator defines the the validator info.", + "type": "object", + "properties": { + "operator_address": { + "type": "string", + "format": "byte" + }, + "consensus_pubkey": { + "type": "string" + }, + "jailed": { + "type": "boolean", + "format": "boolean" + }, + "status": { + "type": "integer", + "format": "int32" + }, + "tokens": { + "type": "string" + }, + "delegator_shares": { + "type": "string" + }, + "description": { + "type": "object", + "properties": { + "moniker": { + "type": "string" + }, + "identity": { + "type": "string" + }, + "website": { + "type": "string" + }, + "security_contact": { + "type": "string" + }, + "details": { + "type": "string" + } + }, + "description": "Description defines a validator description." + }, + "unbonding_height": { + "type": "string", + "format": "int64" + }, + "unbonding_time": { + "type": "string", + "format": "date-time" + }, + "commission": { + "type": "object", + "properties": { + "commission_rates": { + "type": "object", + "properties": { + "rate": { + "type": "string" + }, + "max_rate": { + "type": "string" + }, + "max_change_rate": { + "type": "string" + } + }, + "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + }, + "update_time": { + "type": "string", + "format": "date-time" + } + }, + "description": "Commission defines a commission parameters for a given validator." + }, + "min_self_delegation": { + "type": "string" + } + } + } + }, + "title": "QueryValidatorResponse is response type for the Query/Validator RPC method" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "validator_addr", + "description": "validator_addr defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/validators/{validator_addr}/delegations": { + "get": { + "summary": "ValidatorDelegations queries delegate info for given validator.", + "operationId": "ValidatorDelegations", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "delegation_responses": { + "type": "array", + "items": { + "type": "object", + "properties": { + "delegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "shares": { + "type": "string" + } + }, + "description": "Delegation represents the bond with tokens held by an account. It is\nowned by one delegator, and is associated with the voting power of one\nvalidator." + }, + "balance": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + } + }, + "description": "DelegationResponse is equivalent to Delegation except that it contains a balance\nin addition to shares which is more suitable for client responses." + } + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "title": "QueryValidatorDelegationsResponse is response type for the Query/ValidatorDelegations RPC method" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "validator_addr", + "description": "validator_addr defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}": { + "get": { + "summary": "Delegation queries delegate info for given validator delegator pair.", + "operationId": "Delegation", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "delegation_response": { + "description": "delegation_responses defines the delegation info of a delegation.", + "type": "object", + "properties": { + "delegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "shares": { + "type": "string" + } + }, + "description": "Delegation represents the bond with tokens held by an account. It is\nowned by one delegator, and is associated with the voting power of one\nvalidator." + }, + "balance": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + } + } + } + }, + "description": "QueryDelegationResponse is response type for the Query/Delegation RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "validator_addr", + "description": "validator_addr defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "delegator_addr", + "description": "delegator_addr defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}/unbonding_delegation": { + "get": { + "summary": "UnbondingDelegation queries unbonding info for given validator delegator pair.", + "operationId": "UnbondingDelegation", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "unbond": { + "description": "unbond defines the unbonding information of a delegation.", + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "entries": { + "type": "array", + "items": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "balance": { + "type": "string" + } + }, + "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." + } + } + }, + "title": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list" + } + }, + "description": "QueryDelegationResponse is response type for the Query/UnbondingDelegation RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "validator_addr", + "description": "validator_addr defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "delegator_addr", + "description": "delegator_addr defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/validators/{validator_addr}/unbonding_delegations": { + "get": { + "summary": "ValidatorUnbondingDelegations queries unbonding delegations of a validator.", + "operationId": "ValidatorUnbondingDelegations", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "unbonding_responses": { + "type": "array", + "items": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "entries": { + "type": "array", + "items": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "balance": { + "type": "string" + } + }, + "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." + } + } + }, + "title": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list" + } + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "description": "QueryValidatorUnbondingDelegationsResponse is response type for the Query/ValidatorUnbondingDelegations RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "validator_addr", + "description": "validator_addr defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/upgrade/v1beta1/applied_plan/{name}": { + "get": { + "summary": "AppliedPlan queries a previously applied upgrade plan by its name.", + "operationId": "AppliedPlan", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "height": { + "type": "string", + "format": "int64", + "description": "height is the block height at which the plan was applied." + } + }, + "description": "QueryAppliedPlanResponse is the response type for the Query/AppliedPlan RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "name", + "description": "name is the name of the applied plan to query for.", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/upgrade/v1beta1/current_plan": { + "get": { + "summary": "CurrentPlan queries the current upgrade plan.", + "operationId": "CurrentPlan", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "plan": { + "description": "plan is the current upgrade plan.", + "type": "object", + "properties": { + "name": { + "type": "string", + "description": "Sets the name for the upgrade. This name will be used by the upgraded version of the software to apply any\nspecial \"on-upgrade\" commands during the first BeginBlock method after the upgrade is applied. It is also used\nto detect whether a software version can handle a given upgrade. If no upgrade handler with this name has been\nset in the software, it will be assumed that the software is out-of-date when the upgrade Time or Height\nis reached and the software will exit." + }, + "time": { + "type": "string", + "format": "date-time", + "description": "The time after which the upgrade must be performed.\nLeave set to its zero value to use a pre-defined Height instead." + }, + "height": { + "type": "string", + "format": "int64", + "description": "The height at which the upgrade must be performed.\nOnly used if Time is not set." + }, + "info": { + "type": "string", + "title": "Any application specific upgrade info to be included on-chain\nsuch as a git commit that validators could automatically upgrade to" + } + }, + "title": "Plan specifies information about a planned upgrade and when it should occur" + } + }, + "description": "QueryCurrentPlanResponse is the response type for the Query/CurrentPlan RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "cosmos.auth.v1beta1.Params": { + "type": "object", + "properties": { + "max_memo_characters": { + "type": "string", + "format": "uint64" + }, + "tx_sig_limit": { + "type": "string", + "format": "uint64" + }, + "tx_size_cost_per_byte": { + "type": "string", + "format": "uint64" + }, + "sig_verify_cost_ed25519": { + "type": "string", + "format": "uint64" + }, + "sig_verify_cost_secp256k1": { + "type": "string", + "format": "uint64" + } + }, + "description": "Params defines the parameters for the auth module." + }, + "cosmos.auth.v1beta1.QueryAccountResponse": { + "type": "object", + "properties": { + "account": { + "description": "account defines the account of the corresponding address.", + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + } + } + }, + "description": "QueryAccountResponse is the response type for the Query/Account RPC method." + }, + "cosmos.auth.v1beta1.QueryParamsResponse": { + "type": "object", + "properties": { + "params": { + "description": "params defines the parameters of the module.", + "type": "object", + "properties": { + "max_memo_characters": { + "type": "string", + "format": "uint64" + }, + "tx_sig_limit": { + "type": "string", + "format": "uint64" + }, + "tx_size_cost_per_byte": { + "type": "string", + "format": "uint64" + }, + "sig_verify_cost_ed25519": { + "type": "string", + "format": "uint64" + }, + "sig_verify_cost_secp256k1": { + "type": "string", + "format": "uint64" + } + } + } + }, + "description": "QueryParamsResponse is the response type for the Query/Params RPC method." + }, + "google.protobuf.Any": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "grpc.gateway.runtime.Error": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + }, + "cosmos.bank.v1beta1.Params": { + "type": "object", + "properties": { + "send_enabled": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "enabled": { + "type": "boolean", + "format": "boolean" + } + }, + "title": "Send enabled configuration properties for each denomination" + } + }, + "default_send_enabled": { + "type": "boolean", + "format": "boolean" + } + }, + "description": "Params defines the set of bank parameters." + }, + "cosmos.bank.v1beta1.QueryAllBalancesResponse": { + "type": "object", + "properties": { + "balances": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + }, + "description": "balances is the balances of all the coins." + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "description": "QueryAllBalancesResponse is the response type for the Query/AllBalances RPC method." + }, + "cosmos.bank.v1beta1.QueryBalanceResponse": { + "type": "object", + "properties": { + "balance": { + "description": "balance is the balance of the coin.", + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + } + } + }, + "description": "QueryBalanceResponse is the response type for the Query/Balance RPC method." + }, + "cosmos.bank.v1beta1.QueryParamsResponse": { + "type": "object", + "properties": { + "params": { + "type": "object", + "properties": { + "send_enabled": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "enabled": { + "type": "boolean", + "format": "boolean" + } + }, + "title": "Send enabled configuration properties for each denomination" + } + }, + "default_send_enabled": { + "type": "boolean", + "format": "boolean" + } + }, + "description": "Params defines the set of bank parameters." + } + }, + "description": "QueryParamsResponse defines the response type for querying x/bank parameters." + }, + "cosmos.bank.v1beta1.QuerySupplyOfResponse": { + "type": "object", + "properties": { + "amount": { + "description": "amount is the supply of the coin.", + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + } + } + }, + "description": "QuerySupplyOfResponse is the response type for the Query/SupplyOf RPC method." + }, + "cosmos.bank.v1beta1.QueryTotalSupplyResponse": { + "type": "object", + "properties": { + "supply": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + }, + "title": "supply is the supply of the coins" + } + }, + "title": "QueryTotalSupplyResponse is the response type for the Query/TotalSupply RPC method" + }, + "cosmos.bank.v1beta1.SendEnabled": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "enabled": { + "type": "boolean", + "format": "boolean" + } + }, + "title": "Send enabled configuration properties for each denomination" + }, + "cosmos.base.query.v1beta1.PageRequest": { + "type": "object", + "properties": { + "key": { + "type": "string", + "format": "byte", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." + }, + "offset": { + "type": "string", + "format": "uint64", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." + }, + "limit": { + "type": "string", + "format": "uint64", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." + }, + "count_total": { + "type": "boolean", + "format": "boolean", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." + } + }, + "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", + "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" + }, + "cosmos.base.query.v1beta1.PageResponse": { + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + }, + "cosmos.base.v1beta1.Coin": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + }, + "cosmos.base.v1beta1.DecCoin": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "DecCoin defines a token with a denomination and a decimal amount.\n\nNOTE: The amount field is an Dec which implements the custom method\nsignatures required by gogoproto." + }, + "cosmos.distribution.v1beta1.DelegationDelegatorReward": { + "type": "object", + "properties": { + "validator_address": { + "type": "string", + "format": "byte" + }, + "reward": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "DecCoin defines a token with a denomination and a decimal amount.\n\nNOTE: The amount field is an Dec which implements the custom method\nsignatures required by gogoproto." + } + } + }, + "description": "DelegationDelegatorReward defines the properties\nof a delegator's delegation reward." + }, + "cosmos.distribution.v1beta1.Params": { + "type": "object", + "properties": { + "community_tax": { + "type": "string" + }, + "base_proposer_reward": { + "type": "string" + }, + "bonus_proposer_reward": { + "type": "string" + }, + "withdraw_addr_enabled": { + "type": "boolean", + "format": "boolean" + } + }, + "description": "Params defines the set of distribution parameters." + }, + "cosmos.distribution.v1beta1.QueryCommunityPoolResponse": { + "type": "object", + "properties": { + "pool": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "DecCoin defines a token with a denomination and a decimal amount.\n\nNOTE: The amount field is an Dec which implements the custom method\nsignatures required by gogoproto." + }, + "description": "pool defines community pool's coins." + } + }, + "description": "QueryCommunityPoolResponse is the response type for the Query/CommunityPool RPC method." + }, + "cosmos.distribution.v1beta1.QueryDelegationRewardsResponse": { + "type": "object", + "properties": { + "rewards": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "DecCoin defines a token with a denomination and a decimal amount.\n\nNOTE: The amount field is an Dec which implements the custom method\nsignatures required by gogoproto." + }, + "description": "rewards defines the rewards accrued by a delegation." + } + }, + "description": "QueryDelegationRewardsResponse is the response type for the Query/DelegationRewards RPC method." + }, + "cosmos.distribution.v1beta1.QueryDelegationTotalRewardsResponse": { + "type": "object", + "properties": { + "rewards": { + "type": "array", + "items": { + "type": "object", + "properties": { + "validator_address": { + "type": "string", + "format": "byte" + }, + "reward": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "DecCoin defines a token with a denomination and a decimal amount.\n\nNOTE: The amount field is an Dec which implements the custom method\nsignatures required by gogoproto." + } + } + }, + "description": "DelegationDelegatorReward defines the properties\nof a delegator's delegation reward." + }, + "description": "rewards defines all the rewards accrued by a delegator." + }, + "total": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "DecCoin defines a token with a denomination and a decimal amount.\n\nNOTE: The amount field is an Dec which implements the custom method\nsignatures required by gogoproto." + }, + "description": "total defines the sum of all the rewards." + } + }, + "description": "QueryDelegationTotalRewardsResponse is the response type for the Query/DelegationTotalRewards RPC method." + }, + "cosmos.distribution.v1beta1.QueryDelegatorValidatorsResponse": { + "type": "object", + "properties": { + "validators": { + "type": "array", + "items": { + "type": "string", + "format": "byte" + }, + "description": "validators defines the validators a delegator is delegating for." + } + }, + "description": "QueryDelegatorValidatorsResponse is the response type for the Query/DelegatorValidators RPC method." + }, + "cosmos.distribution.v1beta1.QueryDelegatorWithdrawAddressResponse": { + "type": "object", + "properties": { + "withdraw_address": { + "type": "string", + "format": "byte", + "description": "withdraw_address defines the delegator address to query for." + } + }, + "description": "QueryDelegatorWithdrawAddressResponse is the response type for the Query/DelegatorWithdrawAddress RPC method." + }, + "cosmos.distribution.v1beta1.QueryParamsResponse": { + "type": "object", + "properties": { + "params": { + "description": "params defines the parameters of the module.", + "type": "object", + "properties": { + "community_tax": { + "type": "string" + }, + "base_proposer_reward": { + "type": "string" + }, + "bonus_proposer_reward": { + "type": "string" + }, + "withdraw_addr_enabled": { + "type": "boolean", + "format": "boolean" + } + } + } + }, + "description": "QueryParamsResponse is the response type for the Query/Params RPC method." + }, + "cosmos.distribution.v1beta1.QueryValidatorCommissionResponse": { + "type": "object", + "properties": { + "commission": { + "description": "commission defines the commision the validator received.", + "type": "object", + "properties": { + "commission": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "DecCoin defines a token with a denomination and a decimal amount.\n\nNOTE: The amount field is an Dec which implements the custom method\nsignatures required by gogoproto." + } + } + }, + "title": "accumulated commission for a validator\nkept as a running counter, can be withdrawn at any time" + } + }, + "title": "QueryValidatorCommissionResponse is the response type for the Query/ValidatorCommission RPC method" + }, + "cosmos.distribution.v1beta1.QueryValidatorOutstandingRewardsResponse": { + "type": "object", + "properties": { + "rewards": { + "type": "object", + "properties": { + "rewards": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "DecCoin defines a token with a denomination and a decimal amount.\n\nNOTE: The amount field is an Dec which implements the custom method\nsignatures required by gogoproto." + } + } + }, + "title": "outstanding (un-withdrawn) rewards for a validator\ninexpensive to track, allows simple sanity checks" + } + }, + "description": "QueryValidatorOutstandingRewardsResponse is the response type for the Query/ValidatorOutstandingRewards RPC method." + }, + "cosmos.distribution.v1beta1.QueryValidatorSlashesResponse": { + "type": "object", + "properties": { + "slashes": { + "type": "array", + "items": { + "type": "object", + "properties": { + "validator_period": { + "type": "string", + "format": "uint64" + }, + "fraction": { + "type": "string" + } + }, + "title": "validator slash event\nheight is implicit within the store key\nneeded to calculate appropriate amounts of staking token\nfor delegations which withdraw after a slash has occurred" + }, + "description": "slashes defines the slashes the validator received." + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "description": "QueryValidatorSlashesResponse is the response type for the Query/ValidatorSlashes RPC method." + }, + "cosmos.distribution.v1beta1.ValidatorAccumulatedCommission": { + "type": "object", + "properties": { + "commission": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "DecCoin defines a token with a denomination and a decimal amount.\n\nNOTE: The amount field is an Dec which implements the custom method\nsignatures required by gogoproto." + } + } + }, + "title": "accumulated commission for a validator\nkept as a running counter, can be withdrawn at any time" + }, + "cosmos.distribution.v1beta1.ValidatorOutstandingRewards": { + "type": "object", + "properties": { + "rewards": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "DecCoin defines a token with a denomination and a decimal amount.\n\nNOTE: The amount field is an Dec which implements the custom method\nsignatures required by gogoproto." + } + } + }, + "title": "outstanding (un-withdrawn) rewards for a validator\ninexpensive to track, allows simple sanity checks" + }, + "cosmos.distribution.v1beta1.ValidatorSlashEvent": { + "type": "object", + "properties": { + "validator_period": { + "type": "string", + "format": "uint64" + }, + "fraction": { + "type": "string" + } + }, + "title": "validator slash event\nheight is implicit within the store key\nneeded to calculate appropriate amounts of staking token\nfor delegations which withdraw after a slash has occurred" + }, + "cosmos.evidence.v1beta1.QueryAllEvidenceResponse": { + "type": "object", + "properties": { + "evidence": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "description": "evidence returns all evidences." + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "description": "QueryAllEvidenceResponse is the response type for the Query/AllEvidence RPC method." + }, + "cosmos.evidence.v1beta1.QueryEvidenceResponse": { + "type": "object", + "properties": { + "evidence": { + "description": "evidence returns the requested evidence.", + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + } + } + }, + "description": "QueryEvidenceResponse is the response type for the Query/Evidence RPC method." + }, + "cosmos.gov.v1beta1.Deposit": { + "type": "object", + "properties": { + "proposal_id": { + "type": "string", + "format": "uint64" + }, + "depositor": { + "type": "string", + "format": "byte" + }, + "amount": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + } + } + }, + "title": "Deposit defines an amount deposited by an account address to an active proposal" + }, + "cosmos.gov.v1beta1.DepositParams": { + "type": "object", + "properties": { + "min_deposit": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + }, + "description": "Minimum deposit for a proposal to enter voting period." + }, + "max_deposit_period": { + "type": "string", + "description": "Maximum period for Atom holders to deposit on a proposal. Initial value: 2 months." + } + }, + "title": "DepositParams defines the params around deposits for governance" + }, + "cosmos.gov.v1beta1.Proposal": { + "type": "object", + "properties": { + "proposal_id": { + "type": "string", + "format": "uint64" + }, + "content": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "status": { + "type": "string", + "enum": [ + "PROPOSAL_STATUS_UNSPECIFIED", + "PROPOSAL_STATUS_DEPOSIT_PERIOD", + "PROPOSAL_STATUS_VOTING_PERIOD", + "PROPOSAL_STATUS_PASSED", + "PROPOSAL_STATUS_REJECTED", + "PROPOSAL_STATUS_FAILED" + ], + "default": "PROPOSAL_STATUS_UNSPECIFIED", + "description": "- PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed.", + "title": "ProposalStatus is a type alias that represents a proposal status as a byte" + }, + "final_tally_result": { + "type": "object", + "properties": { + "yes": { + "type": "string" + }, + "abstain": { + "type": "string" + }, + "no": { + "type": "string" + }, + "no_with_veto": { + "type": "string" + } + }, + "title": "TallyResult defines a standard tally for a proposal" + }, + "submit_time": { + "type": "string", + "format": "date-time" + }, + "deposit_end_time": { + "type": "string", + "format": "date-time" + }, + "total_deposit": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + } + }, + "voting_start_time": { + "type": "string", + "format": "date-time" + }, + "voting_end_time": { + "type": "string", + "format": "date-time" + } + }, + "title": "Proposal defines the core field members of a governance proposal" + }, + "cosmos.gov.v1beta1.ProposalStatus": { + "type": "string", + "enum": [ + "PROPOSAL_STATUS_UNSPECIFIED", + "PROPOSAL_STATUS_DEPOSIT_PERIOD", + "PROPOSAL_STATUS_VOTING_PERIOD", + "PROPOSAL_STATUS_PASSED", + "PROPOSAL_STATUS_REJECTED", + "PROPOSAL_STATUS_FAILED" + ], + "default": "PROPOSAL_STATUS_UNSPECIFIED", + "description": "- PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed.", + "title": "ProposalStatus is a type alias that represents a proposal status as a byte" + }, + "cosmos.gov.v1beta1.QueryDepositResponse": { + "type": "object", + "properties": { + "deposit": { + "description": "deposit defines the requested deposit.", + "type": "object", + "properties": { + "proposal_id": { + "type": "string", + "format": "uint64" + }, + "depositor": { + "type": "string", + "format": "byte" + }, + "amount": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + } + } + }, + "title": "Deposit defines an amount deposited by an account address to an active proposal" + } + }, + "description": "QueryDepositResponse is the response type for the Query/Deposit RPC method." + }, + "cosmos.gov.v1beta1.QueryDepositsResponse": { + "type": "object", + "properties": { + "deposits": { + "type": "array", + "items": { + "type": "object", + "properties": { + "proposal_id": { + "type": "string", + "format": "uint64" + }, + "depositor": { + "type": "string", + "format": "byte" + }, + "amount": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + } + } + }, + "title": "Deposit defines an amount deposited by an account address to an active proposal" + } + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "description": "QueryDepositsResponse is the response type for the Query/Deposits RPC method." + }, + "cosmos.gov.v1beta1.QueryParamsResponse": { + "type": "object", + "properties": { + "voting_params": { + "description": "voting_params defines the parameters related to voting.", + "type": "object", + "properties": { + "voting_period": { + "type": "string", + "description": "Length of the voting period." + } + }, + "title": "VotingParams defines the params around Voting in governance" + }, + "deposit_params": { + "description": "deposit_params defines the parameters related to deposit.", + "type": "object", + "properties": { + "min_deposit": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + }, + "description": "Minimum deposit for a proposal to enter voting period." + }, + "max_deposit_period": { + "type": "string", + "description": "Maximum period for Atom holders to deposit on a proposal. Initial value: 2 months." + } + }, + "title": "DepositParams defines the params around deposits for governance" + }, + "tally_params": { + "description": "tally_params defines the parameters related to tally.", + "type": "object", + "properties": { + "quorum": { + "type": "string", + "format": "byte", + "description": "Minimum percentage of total stake needed to vote for a result to be considered valid." + }, + "threshold": { + "type": "string", + "format": "byte", + "description": "Minimum proportion of Yes votes for proposal to pass. Initial value: 0.5." + }, + "veto": { + "type": "string", + "format": "byte", + "description": "Minimum value of Veto votes to Total votes ratio for proposal to be vetoed. Initial value: 1/3." + } + }, + "title": "TallyParams defines the params around Tallying votes in governance" + } + }, + "description": "QueryParamsResponse is the response type for the Query/Params RPC method." + }, + "cosmos.gov.v1beta1.QueryProposalResponse": { + "type": "object", + "properties": { + "proposal": { + "type": "object", + "properties": { + "proposal_id": { + "type": "string", + "format": "uint64" + }, + "content": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "status": { + "type": "string", + "enum": [ + "PROPOSAL_STATUS_UNSPECIFIED", + "PROPOSAL_STATUS_DEPOSIT_PERIOD", + "PROPOSAL_STATUS_VOTING_PERIOD", + "PROPOSAL_STATUS_PASSED", + "PROPOSAL_STATUS_REJECTED", + "PROPOSAL_STATUS_FAILED" + ], + "default": "PROPOSAL_STATUS_UNSPECIFIED", + "description": "- PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed.", + "title": "ProposalStatus is a type alias that represents a proposal status as a byte" + }, + "final_tally_result": { + "type": "object", + "properties": { + "yes": { + "type": "string" + }, + "abstain": { + "type": "string" + }, + "no": { + "type": "string" + }, + "no_with_veto": { + "type": "string" + } + }, + "title": "TallyResult defines a standard tally for a proposal" + }, + "submit_time": { + "type": "string", + "format": "date-time" + }, + "deposit_end_time": { + "type": "string", + "format": "date-time" + }, + "total_deposit": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + } + }, + "voting_start_time": { + "type": "string", + "format": "date-time" + }, + "voting_end_time": { + "type": "string", + "format": "date-time" + } + }, + "title": "Proposal defines the core field members of a governance proposal" + } + }, + "description": "QueryProposalResponse is the response type for the Query/Proposal RPC method." + }, + "cosmos.gov.v1beta1.QueryProposalsResponse": { + "type": "object", + "properties": { + "proposals": { + "type": "array", + "items": { + "type": "object", + "properties": { + "proposal_id": { + "type": "string", + "format": "uint64" + }, + "content": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "status": { + "type": "string", + "enum": [ + "PROPOSAL_STATUS_UNSPECIFIED", + "PROPOSAL_STATUS_DEPOSIT_PERIOD", + "PROPOSAL_STATUS_VOTING_PERIOD", + "PROPOSAL_STATUS_PASSED", + "PROPOSAL_STATUS_REJECTED", + "PROPOSAL_STATUS_FAILED" + ], + "default": "PROPOSAL_STATUS_UNSPECIFIED", + "description": "- PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed.", + "title": "ProposalStatus is a type alias that represents a proposal status as a byte" + }, + "final_tally_result": { + "type": "object", + "properties": { + "yes": { + "type": "string" + }, + "abstain": { + "type": "string" + }, + "no": { + "type": "string" + }, + "no_with_veto": { + "type": "string" + } + }, + "title": "TallyResult defines a standard tally for a proposal" + }, + "submit_time": { + "type": "string", + "format": "date-time" + }, + "deposit_end_time": { + "type": "string", + "format": "date-time" + }, + "total_deposit": { + "type": "array", + "items": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + } + }, + "voting_start_time": { + "type": "string", + "format": "date-time" + }, + "voting_end_time": { + "type": "string", + "format": "date-time" + } + }, + "title": "Proposal defines the core field members of a governance proposal" + } + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "description": "QueryProposalsResponse is the response type for the Query/Proposals RPC method." + }, + "cosmos.gov.v1beta1.QueryTallyResultResponse": { + "type": "object", + "properties": { + "tally": { + "description": "tally defines the requested tally.", + "type": "object", + "properties": { + "yes": { + "type": "string" + }, + "abstain": { + "type": "string" + }, + "no": { + "type": "string" + }, + "no_with_veto": { + "type": "string" + } + }, + "title": "TallyResult defines a standard tally for a proposal" + } + }, + "description": "QueryTallyResultResponse is the response type for the Query/Tally RPC method." + }, + "cosmos.gov.v1beta1.QueryVoteResponse": { + "type": "object", + "properties": { + "vote": { + "description": "vote defined the queried vote.", + "type": "object", + "properties": { + "proposal_id": { + "type": "string", + "format": "uint64" + }, + "voter": { + "type": "string", + "format": "byte" + }, + "option": { + "type": "string", + "enum": [ + "VOTE_OPTION_UNSPECIFIED", + "VOTE_OPTION_YES", + "VOTE_OPTION_ABSTAIN", + "VOTE_OPTION_NO", + "VOTE_OPTION_NO_WITH_VETO" + ], + "default": "VOTE_OPTION_UNSPECIFIED", + "description": "- VOTE_OPTION_UNSPECIFIED: VOTE_OPTION_UNSPECIFIED defines a no-op vote option.\n - VOTE_OPTION_YES: VOTE_OPTION_YES defines a yes vote option.\n - VOTE_OPTION_ABSTAIN: VOTE_OPTION_ABSTAIN defines an abstain vote option.\n - VOTE_OPTION_NO: VOTE_OPTION_NO defines a no vote option.\n - VOTE_OPTION_NO_WITH_VETO: VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option.", + "title": "VoteOption defines a vote option" + } + } + } + }, + "description": "QueryVoteResponse is the response type for the Query/Vote RPC method." + }, + "cosmos.gov.v1beta1.QueryVotesResponse": { + "type": "object", + "properties": { + "votes": { + "type": "array", + "items": { + "type": "object", + "properties": { + "proposal_id": { + "type": "string", + "format": "uint64" + }, + "voter": { + "type": "string", + "format": "byte" + }, + "option": { + "type": "string", + "enum": [ + "VOTE_OPTION_UNSPECIFIED", + "VOTE_OPTION_YES", + "VOTE_OPTION_ABSTAIN", + "VOTE_OPTION_NO", + "VOTE_OPTION_NO_WITH_VETO" + ], + "default": "VOTE_OPTION_UNSPECIFIED", + "description": "- VOTE_OPTION_UNSPECIFIED: VOTE_OPTION_UNSPECIFIED defines a no-op vote option.\n - VOTE_OPTION_YES: VOTE_OPTION_YES defines a yes vote option.\n - VOTE_OPTION_ABSTAIN: VOTE_OPTION_ABSTAIN defines an abstain vote option.\n - VOTE_OPTION_NO: VOTE_OPTION_NO defines a no vote option.\n - VOTE_OPTION_NO_WITH_VETO: VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option.", + "title": "VoteOption defines a vote option" + } + }, + "description": "Vote defines a vote on a governance proposal. A vote corresponds to a proposal\nID, the voter, and the vote option." + }, + "description": "votes defined the queried votes." + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "description": "QueryVotesResponse is the response type for the Query/Votes RPC method." + }, + "cosmos.gov.v1beta1.TallyParams": { + "type": "object", + "properties": { + "quorum": { + "type": "string", + "format": "byte", + "description": "Minimum percentage of total stake needed to vote for a result to be considered valid." + }, + "threshold": { + "type": "string", + "format": "byte", + "description": "Minimum proportion of Yes votes for proposal to pass. Initial value: 0.5." + }, + "veto": { + "type": "string", + "format": "byte", + "description": "Minimum value of Veto votes to Total votes ratio for proposal to be vetoed. Initial value: 1/3." + } + }, + "title": "TallyParams defines the params around Tallying votes in governance" + }, + "cosmos.gov.v1beta1.TallyResult": { + "type": "object", + "properties": { + "yes": { + "type": "string" + }, + "abstain": { + "type": "string" + }, + "no": { + "type": "string" + }, + "no_with_veto": { + "type": "string" + } + }, + "title": "TallyResult defines a standard tally for a proposal" + }, + "cosmos.gov.v1beta1.Vote": { + "type": "object", + "properties": { + "proposal_id": { + "type": "string", + "format": "uint64" + }, + "voter": { + "type": "string", + "format": "byte" + }, + "option": { + "type": "string", + "enum": [ + "VOTE_OPTION_UNSPECIFIED", + "VOTE_OPTION_YES", + "VOTE_OPTION_ABSTAIN", + "VOTE_OPTION_NO", + "VOTE_OPTION_NO_WITH_VETO" + ], + "default": "VOTE_OPTION_UNSPECIFIED", + "description": "- VOTE_OPTION_UNSPECIFIED: VOTE_OPTION_UNSPECIFIED defines a no-op vote option.\n - VOTE_OPTION_YES: VOTE_OPTION_YES defines a yes vote option.\n - VOTE_OPTION_ABSTAIN: VOTE_OPTION_ABSTAIN defines an abstain vote option.\n - VOTE_OPTION_NO: VOTE_OPTION_NO defines a no vote option.\n - VOTE_OPTION_NO_WITH_VETO: VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option.", + "title": "VoteOption defines a vote option" + } + }, + "description": "Vote defines a vote on a governance proposal. A vote corresponds to a proposal\nID, the voter, and the vote option." + }, + "cosmos.gov.v1beta1.VoteOption": { + "type": "string", + "enum": [ + "VOTE_OPTION_UNSPECIFIED", + "VOTE_OPTION_YES", + "VOTE_OPTION_ABSTAIN", + "VOTE_OPTION_NO", + "VOTE_OPTION_NO_WITH_VETO" + ], + "default": "VOTE_OPTION_UNSPECIFIED", + "description": "- VOTE_OPTION_UNSPECIFIED: VOTE_OPTION_UNSPECIFIED defines a no-op vote option.\n - VOTE_OPTION_YES: VOTE_OPTION_YES defines a yes vote option.\n - VOTE_OPTION_ABSTAIN: VOTE_OPTION_ABSTAIN defines an abstain vote option.\n - VOTE_OPTION_NO: VOTE_OPTION_NO defines a no vote option.\n - VOTE_OPTION_NO_WITH_VETO: VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option.", + "title": "VoteOption defines a vote option" + }, + "cosmos.gov.v1beta1.VotingParams": { + "type": "object", + "properties": { + "voting_period": { + "type": "string", + "description": "Length of the voting period." + } + }, + "title": "VotingParams defines the params around Voting in governance" + }, + "cosmos.mint.v1beta1.Params": { + "type": "object", + "properties": { + "mint_denom": { + "type": "string", + "title": "type of coin to mint" + }, + "inflation_rate_change": { + "type": "string", + "title": "maximum annual change in inflation rate" + }, + "inflation_max": { + "type": "string", + "title": "maximum inflation rate" + }, + "inflation_min": { + "type": "string", + "title": "minimum inflation rate" + }, + "goal_bonded": { + "type": "string", + "title": "goal of percent bonded atoms" + }, + "blocks_per_year": { + "type": "string", + "format": "uint64", + "title": "expected blocks per year" + } + }, + "title": "mint parameters" + }, + "cosmos.mint.v1beta1.QueryAnnualProvisionsResponse": { + "type": "object", + "properties": { + "annual_provisions": { + "type": "string", + "format": "byte", + "description": "annual_provisions is the current minting annual provisions value." + } + }, + "description": "QueryAnnualProvisionsResponse is the response type for the Query/AnnualProvisions RPC method." + }, + "cosmos.mint.v1beta1.QueryInflationResponse": { + "type": "object", + "properties": { + "inflation": { + "type": "string", + "format": "byte", + "description": "inflation is the current minting inflation value." + } + }, + "description": "QueryInflationResponse is the response type for the Query/Inflation RPC method." + }, + "cosmos.mint.v1beta1.QueryParamsResponse": { + "type": "object", + "properties": { + "params": { + "description": "params defines the parameters of the module.", + "type": "object", + "properties": { + "mint_denom": { + "type": "string", + "title": "type of coin to mint" + }, + "inflation_rate_change": { + "type": "string", + "title": "maximum annual change in inflation rate" + }, + "inflation_max": { + "type": "string", + "title": "maximum inflation rate" + }, + "inflation_min": { + "type": "string", + "title": "minimum inflation rate" + }, + "goal_bonded": { + "type": "string", + "title": "goal of percent bonded atoms" + }, + "blocks_per_year": { + "type": "string", + "format": "uint64", + "title": "expected blocks per year" + } + }, + "title": "mint parameters" + } + }, + "description": "QueryParamsResponse is the response type for the Query/Params RPC method." + }, + "cosmos.params.v1beta1.ParamChange": { + "type": "object", + "properties": { + "subspace": { + "type": "string" + }, + "key": { + "type": "string" + }, + "value": { + "type": "string" + } + }, + "description": "ParamChange defines a parameter change." + }, + "cosmos.params.v1beta1.QueryParamsResponse": { + "type": "object", + "properties": { + "param": { + "description": "param defines the queried parameter.", + "type": "object", + "properties": { + "subspace": { + "type": "string" + }, + "key": { + "type": "string" + }, + "value": { + "type": "string" + } + } + } + }, + "description": "QueryParamsResponse is response type for the Query/Params RPC method." + }, + "cosmos.slashing.v1beta1.Params": { + "type": "object", + "properties": { + "signed_blocks_window": { + "type": "string", + "format": "int64" + }, + "min_signed_per_window": { + "type": "string", + "format": "byte" + }, + "downtime_jail_duration": { + "type": "string" + }, + "slash_fraction_double_sign": { + "type": "string", + "format": "byte" + }, + "slash_fraction_downtime": { + "type": "string", + "format": "byte" + } + }, + "title": "Params - used for initializing default parameter for slashing at genesis" + }, + "cosmos.slashing.v1beta1.QueryParamsResponse": { + "type": "object", + "properties": { + "params": { + "type": "object", + "properties": { + "signed_blocks_window": { + "type": "string", + "format": "int64" + }, + "min_signed_per_window": { + "type": "string", + "format": "byte" + }, + "downtime_jail_duration": { + "type": "string" + }, + "slash_fraction_double_sign": { + "type": "string", + "format": "byte" + }, + "slash_fraction_downtime": { + "type": "string", + "format": "byte" + } + }, + "title": "Params - used for initializing default parameter for slashing at genesis" + } + }, + "title": "QueryParamsResponse is the response type for the Query/Params RPC method" + }, + "cosmos.slashing.v1beta1.QuerySigningInfoResponse": { + "type": "object", + "properties": { + "val_signing_info": { + "title": "val_signing_info is the signing info of requested val cons address", + "type": "object", + "properties": { + "address": { + "type": "string", + "format": "byte" + }, + "start_height": { + "type": "string", + "format": "int64", + "title": "height at which validator was first a candidate OR was unjailed" + }, + "index_offset": { + "type": "string", + "format": "int64", + "title": "index offset into signed block bit array" + }, + "jailed_until": { + "type": "string", + "format": "date-time", + "title": "timestamp validator cannot be unjailed until" + }, + "tombstoned": { + "type": "boolean", + "format": "boolean", + "title": "whether or not a validator has been tombstoned (killed out of validator set)" + }, + "missed_blocks_counter": { + "type": "string", + "format": "int64", + "title": "missed blocks counter (to avoid scanning the array every time)" + } + } + } + }, + "title": "QuerySigningInfoResponse is the response type for the Query/SigningInfo RPC method" + }, + "cosmos.slashing.v1beta1.QuerySigningInfosResponse": { + "type": "object", + "properties": { + "info": { + "type": "array", + "items": { + "type": "object", + "properties": { + "address": { + "type": "string", + "format": "byte" + }, + "start_height": { + "type": "string", + "format": "int64", + "title": "height at which validator was first a candidate OR was unjailed" + }, + "index_offset": { + "type": "string", + "format": "int64", + "title": "index offset into signed block bit array" + }, + "jailed_until": { + "type": "string", + "format": "date-time", + "title": "timestamp validator cannot be unjailed until" + }, + "tombstoned": { + "type": "boolean", + "format": "boolean", + "title": "whether or not a validator has been tombstoned (killed out of validator set)" + }, + "missed_blocks_counter": { + "type": "string", + "format": "int64", + "title": "missed blocks counter (to avoid scanning the array every time)" + } + }, + "title": "ValidatorSigningInfo defines the signing info for a validator" + }, + "title": "info is the signing info of all validators" + }, + "pagination": { + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "title": "QuerySigningInfosResponse is the response type for the Query/SigningInfos RPC method" + }, + "cosmos.slashing.v1beta1.ValidatorSigningInfo": { + "type": "object", + "properties": { + "address": { + "type": "string", + "format": "byte" + }, + "start_height": { + "type": "string", + "format": "int64", + "title": "height at which validator was first a candidate OR was unjailed" + }, + "index_offset": { + "type": "string", + "format": "int64", + "title": "index offset into signed block bit array" + }, + "jailed_until": { + "type": "string", + "format": "date-time", + "title": "timestamp validator cannot be unjailed until" + }, + "tombstoned": { + "type": "boolean", + "format": "boolean", + "title": "whether or not a validator has been tombstoned (killed out of validator set)" + }, + "missed_blocks_counter": { + "type": "string", + "format": "int64", + "title": "missed blocks counter (to avoid scanning the array every time)" + } + }, + "title": "ValidatorSigningInfo defines the signing info for a validator" + }, + "cosmos.staking.v1beta1.Commission": { + "type": "object", + "properties": { + "commission_rates": { + "type": "object", + "properties": { + "rate": { + "type": "string" + }, + "max_rate": { + "type": "string" + }, + "max_change_rate": { + "type": "string" + } + }, + "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + }, + "update_time": { + "type": "string", + "format": "date-time" + } + }, + "description": "Commission defines a commission parameters for a given validator." + }, + "cosmos.staking.v1beta1.CommissionRates": { + "type": "object", + "properties": { + "rate": { + "type": "string" + }, + "max_rate": { + "type": "string" + }, + "max_change_rate": { + "type": "string" + } + }, + "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + }, + "cosmos.staking.v1beta1.Delegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "shares": { + "type": "string" + } + }, + "description": "Delegation represents the bond with tokens held by an account. It is\nowned by one delegator, and is associated with the voting power of one\nvalidator." + }, + "cosmos.staking.v1beta1.DelegationResponse": { + "type": "object", + "properties": { + "delegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "shares": { + "type": "string" + } + }, + "description": "Delegation represents the bond with tokens held by an account. It is\nowned by one delegator, and is associated with the voting power of one\nvalidator." + }, + "balance": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + } + }, + "description": "DelegationResponse is equivalent to Delegation except that it contains a balance\nin addition to shares which is more suitable for client responses." + }, + "cosmos.staking.v1beta1.Description": { + "type": "object", + "properties": { + "moniker": { + "type": "string" + }, + "identity": { + "type": "string" + }, + "website": { + "type": "string" + }, + "security_contact": { + "type": "string" + }, + "details": { + "type": "string" + } + }, + "description": "Description defines a validator description." + }, + "cosmos.staking.v1beta1.HistoricalInfo": { + "type": "object", + "properties": { + "header": { + "type": "object", + "properties": { + "version": { + "title": "basic block info", + "type": "object", + "properties": { + "block": { + "type": "string", + "format": "uint64" + }, + "app": { + "type": "string", + "format": "uint64" + } + }, + "description": "Consensus captures the consensus rules for processing a block in the blockchain,\nincluding all blockchain data structures and the rules of the application's\nstate transition machine." + }, + "chain_id": { + "type": "string" + }, + "height": { + "type": "string", + "format": "int64" + }, + "time": { + "type": "string", + "format": "date-time" + }, + "last_block_id": { + "title": "prev block info", + "type": "object", + "properties": { + "hash": { + "type": "string", + "format": "byte" + }, + "part_set_header": { + "type": "object", + "properties": { + "total": { + "type": "integer", + "format": "int64" + }, + "hash": { + "type": "string", + "format": "byte" + } + }, + "title": "PartsetHeader" + } + } + }, + "last_commit_hash": { + "type": "string", + "format": "byte", + "title": "hashes of block data" + }, + "data_hash": { + "type": "string", + "format": "byte" + }, + "validators_hash": { + "type": "string", + "format": "byte", + "title": "hashes from the app output from the prev block" + }, + "next_validators_hash": { + "type": "string", + "format": "byte" + }, + "consensus_hash": { + "type": "string", + "format": "byte" + }, + "app_hash": { + "type": "string", + "format": "byte" + }, + "last_results_hash": { + "type": "string", + "format": "byte" + }, + "evidence_hash": { + "type": "string", + "format": "byte", + "title": "consensus info" + }, + "proposer_address": { + "type": "string", + "format": "byte" + } + }, + "description": "Header defines the structure of a Tendermint block header." + }, + "valset": { + "type": "array", + "items": { + "type": "object", + "properties": { + "operator_address": { + "type": "string", + "format": "byte" + }, + "consensus_pubkey": { + "type": "string" + }, + "jailed": { + "type": "boolean", + "format": "boolean" + }, + "status": { + "type": "integer", + "format": "int32" + }, + "tokens": { + "type": "string" + }, + "delegator_shares": { + "type": "string" + }, + "description": { + "type": "object", + "properties": { + "moniker": { + "type": "string" + }, + "identity": { + "type": "string" + }, + "website": { + "type": "string" + }, + "security_contact": { + "type": "string" + }, + "details": { + "type": "string" + } + }, + "description": "Description defines a validator description." + }, + "unbonding_height": { + "type": "string", + "format": "int64" + }, + "unbonding_time": { + "type": "string", + "format": "date-time" + }, + "commission": { + "type": "object", + "properties": { + "commission_rates": { + "type": "object", + "properties": { + "rate": { + "type": "string" + }, + "max_rate": { + "type": "string" + }, + "max_change_rate": { + "type": "string" + } + }, + "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + }, + "update_time": { + "type": "string", + "format": "date-time" + } + }, + "description": "Commission defines a commission parameters for a given validator." + }, + "min_self_delegation": { + "type": "string" + } + }, + "description": "Validator defines the total amount of bond shares and their exchange rate to\ncoins. Slashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." + } + } + }, + "description": "HistoricalInfo contains the historical information that gets stored at\neach height." + }, + "cosmos.staking.v1beta1.Params": { + "type": "object", + "properties": { + "unbonding_time": { + "type": "string" + }, + "max_validators": { + "type": "integer", + "format": "int64" + }, + "max_entries": { + "type": "integer", + "format": "int64" + }, + "historical_entries": { + "type": "integer", + "format": "int64" + }, + "bond_denom": { + "type": "string" + } + }, + "description": "Params defines the parameters for the staking module." + }, + "cosmos.staking.v1beta1.Pool": { + "type": "object", + "properties": { + "not_bonded_tokens": { + "type": "string" + }, + "bonded_tokens": { + "type": "string" + } + }, + "title": "Pool - tracking bonded and not-bonded token supply of the bond denomination" + }, + "cosmos.staking.v1beta1.QueryDelegationResponse": { + "type": "object", + "properties": { + "delegation_response": { + "description": "delegation_responses defines the delegation info of a delegation.", + "type": "object", + "properties": { + "delegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "shares": { + "type": "string" + } + }, + "description": "Delegation represents the bond with tokens held by an account. It is\nowned by one delegator, and is associated with the voting power of one\nvalidator." + }, + "balance": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + } + } + } + }, + "description": "QueryDelegationResponse is response type for the Query/Delegation RPC method." + }, + "cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse": { + "type": "object", + "properties": { + "delegation_responses": { + "type": "array", + "items": { + "type": "object", + "properties": { + "delegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "shares": { + "type": "string" + } + }, + "description": "Delegation represents the bond with tokens held by an account. It is\nowned by one delegator, and is associated with the voting power of one\nvalidator." + }, + "balance": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + } + }, + "description": "DelegationResponse is equivalent to Delegation except that it contains a balance\nin addition to shares which is more suitable for client responses." + }, + "description": "delegation_responses defines all the delegations' info of a delegator." + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "description": "QueryDelegatorDelegationsResponse is response type for the Query/DelegatorDelegations RPC method." + }, + "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse": { + "type": "object", + "properties": { + "unbonding_responses": { + "type": "array", + "items": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "entries": { + "type": "array", + "items": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "balance": { + "type": "string" + } + }, + "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." + } + } + }, + "title": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list" + } + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "description": "QueryUnbondingDelegatorDelegationsResponse is response type for the Query/UnbondingDelegatorDelegations RPC method." + }, + "cosmos.staking.v1beta1.QueryDelegatorValidatorResponse": { + "type": "object", + "properties": { + "validator": { + "description": "validator defines the the validator info.", + "type": "object", + "properties": { + "operator_address": { + "type": "string", + "format": "byte" + }, + "consensus_pubkey": { + "type": "string" + }, + "jailed": { + "type": "boolean", + "format": "boolean" + }, + "status": { + "type": "integer", + "format": "int32" + }, + "tokens": { + "type": "string" + }, + "delegator_shares": { + "type": "string" + }, + "description": { + "type": "object", + "properties": { + "moniker": { + "type": "string" + }, + "identity": { + "type": "string" + }, + "website": { + "type": "string" + }, + "security_contact": { + "type": "string" + }, + "details": { + "type": "string" + } + }, + "description": "Description defines a validator description." + }, + "unbonding_height": { + "type": "string", + "format": "int64" + }, + "unbonding_time": { + "type": "string", + "format": "date-time" + }, + "commission": { + "type": "object", + "properties": { + "commission_rates": { + "type": "object", + "properties": { + "rate": { + "type": "string" + }, + "max_rate": { + "type": "string" + }, + "max_change_rate": { + "type": "string" + } + }, + "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + }, + "update_time": { + "type": "string", + "format": "date-time" + } + }, + "description": "Commission defines a commission parameters for a given validator." + }, + "min_self_delegation": { + "type": "string" + } + } + } + }, + "description": "QueryDelegatorValidatorResponse response type for the Query/DelegatorValidator RPC method." + }, + "cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse": { + "type": "object", + "properties": { + "validators": { + "type": "array", + "items": { + "type": "object", + "properties": { + "operator_address": { + "type": "string", + "format": "byte" + }, + "consensus_pubkey": { + "type": "string" + }, + "jailed": { + "type": "boolean", + "format": "boolean" + }, + "status": { + "type": "integer", + "format": "int32" + }, + "tokens": { + "type": "string" + }, + "delegator_shares": { + "type": "string" + }, + "description": { + "type": "object", + "properties": { + "moniker": { + "type": "string" + }, + "identity": { + "type": "string" + }, + "website": { + "type": "string" + }, + "security_contact": { + "type": "string" + }, + "details": { + "type": "string" + } + }, + "description": "Description defines a validator description." + }, + "unbonding_height": { + "type": "string", + "format": "int64" + }, + "unbonding_time": { + "type": "string", + "format": "date-time" + }, + "commission": { + "type": "object", + "properties": { + "commission_rates": { + "type": "object", + "properties": { + "rate": { + "type": "string" + }, + "max_rate": { + "type": "string" + }, + "max_change_rate": { + "type": "string" + } + }, + "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + }, + "update_time": { + "type": "string", + "format": "date-time" + } + }, + "description": "Commission defines a commission parameters for a given validator." + }, + "min_self_delegation": { + "type": "string" + } + }, + "description": "Validator defines the total amount of bond shares and their exchange rate to\ncoins. Slashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." + }, + "description": "validators defines the the validators' info of a delegator." + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "description": "QueryDelegatorValidatorsResponse is response type for the Query/DelegatorValidators RPC method." + }, + "cosmos.staking.v1beta1.QueryHistoricalInfoResponse": { + "type": "object", + "properties": { + "hist": { + "description": "hist defines the historical info at the given height.", + "type": "object", + "properties": { + "header": { + "type": "object", + "properties": { + "version": { + "title": "basic block info", + "type": "object", + "properties": { + "block": { + "type": "string", + "format": "uint64" + }, + "app": { + "type": "string", + "format": "uint64" + } + }, + "description": "Consensus captures the consensus rules for processing a block in the blockchain,\nincluding all blockchain data structures and the rules of the application's\nstate transition machine." + }, + "chain_id": { + "type": "string" + }, + "height": { + "type": "string", + "format": "int64" + }, + "time": { + "type": "string", + "format": "date-time" + }, + "last_block_id": { + "title": "prev block info", + "type": "object", + "properties": { + "hash": { + "type": "string", + "format": "byte" + }, + "part_set_header": { + "type": "object", + "properties": { + "total": { + "type": "integer", + "format": "int64" + }, + "hash": { + "type": "string", + "format": "byte" + } + }, + "title": "PartsetHeader" + } + } + }, + "last_commit_hash": { + "type": "string", + "format": "byte", + "title": "hashes of block data" + }, + "data_hash": { + "type": "string", + "format": "byte" + }, + "validators_hash": { + "type": "string", + "format": "byte", + "title": "hashes from the app output from the prev block" + }, + "next_validators_hash": { + "type": "string", + "format": "byte" + }, + "consensus_hash": { + "type": "string", + "format": "byte" + }, + "app_hash": { + "type": "string", + "format": "byte" + }, + "last_results_hash": { + "type": "string", + "format": "byte" + }, + "evidence_hash": { + "type": "string", + "format": "byte", + "title": "consensus info" + }, + "proposer_address": { + "type": "string", + "format": "byte" + } + }, + "description": "Header defines the structure of a Tendermint block header." + }, + "valset": { + "type": "array", + "items": { + "type": "object", + "properties": { + "operator_address": { + "type": "string", + "format": "byte" + }, + "consensus_pubkey": { + "type": "string" + }, + "jailed": { + "type": "boolean", + "format": "boolean" + }, + "status": { + "type": "integer", + "format": "int32" + }, + "tokens": { + "type": "string" + }, + "delegator_shares": { + "type": "string" + }, + "description": { + "type": "object", + "properties": { + "moniker": { + "type": "string" + }, + "identity": { + "type": "string" + }, + "website": { + "type": "string" + }, + "security_contact": { + "type": "string" + }, + "details": { + "type": "string" + } + }, + "description": "Description defines a validator description." + }, + "unbonding_height": { + "type": "string", + "format": "int64" + }, + "unbonding_time": { + "type": "string", + "format": "date-time" + }, + "commission": { + "type": "object", + "properties": { + "commission_rates": { + "type": "object", + "properties": { + "rate": { + "type": "string" + }, + "max_rate": { + "type": "string" + }, + "max_change_rate": { + "type": "string" + } + }, + "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + }, + "update_time": { + "type": "string", + "format": "date-time" + } + }, + "description": "Commission defines a commission parameters for a given validator." + }, + "min_self_delegation": { + "type": "string" + } + }, + "description": "Validator defines the total amount of bond shares and their exchange rate to\ncoins. Slashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." + } + } + } + } + }, + "description": "QueryHistoricalInfoResponse is response type for the Query/HistoricalInfo RPC method." + }, + "cosmos.staking.v1beta1.QueryParamsResponse": { + "type": "object", + "properties": { + "params": { + "description": "params holds all the parameters of this module.", + "type": "object", + "properties": { + "unbonding_time": { + "type": "string" + }, + "max_validators": { + "type": "integer", + "format": "int64" + }, + "max_entries": { + "type": "integer", + "format": "int64" + }, + "historical_entries": { + "type": "integer", + "format": "int64" + }, + "bond_denom": { + "type": "string" + } + } + } + }, + "description": "QueryParamsResponse is response type for the Query/Params RPC method." + }, + "cosmos.staking.v1beta1.QueryPoolResponse": { + "type": "object", + "properties": { + "pool": { + "description": "pool defines the pool info.", + "type": "object", + "properties": { + "not_bonded_tokens": { + "type": "string" + }, + "bonded_tokens": { + "type": "string" + } + }, + "title": "Pool - tracking bonded and not-bonded token supply of the bond denomination" + } + }, + "description": "QueryPoolResponse is response type for the Query/Pool RPC method." + }, + "cosmos.staking.v1beta1.QueryRedelegationsResponse": { + "type": "object", + "properties": { + "redelegation_responses": { + "type": "array", + "items": { + "type": "object", + "properties": { + "redelegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_src_address": { + "type": "string", + "format": "byte" + }, + "validator_dst_address": { + "type": "string", + "format": "byte" + }, + "entries": { + "type": "array", + "items": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "shares_dst": { + "type": "string" + } + }, + "description": "RedelegationEntry defines a redelegation object with relevant metadata." + } + } + }, + "description": "Redelegation contains the list of a particular delegator's redelegating bonds\nfrom a particular source validator to a particular destination validator." + }, + "entries": { + "type": "array", + "items": { + "type": "object", + "properties": { + "redelegation_entry": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "shares_dst": { + "type": "string" + } + }, + "description": "RedelegationEntry defines a redelegation object with relevant metadata." + }, + "balance": { + "type": "string" + } + }, + "description": "RedelegationEntryResponse is equivalent to a RedelegationEntry except that it\ncontains a balance in addition to shares which is more suitable for client\nresponses." + } + } + }, + "description": "RedelegationResponse is equivalent to a Redelegation except that its entries\ncontain a balance in addition to shares which is more suitable for client\nresponses." + } + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "description": "QueryRedelegationsResponse is response type for the Query/Redelegations RPC method." + }, + "cosmos.staking.v1beta1.QueryUnbondingDelegationResponse": { + "type": "object", + "properties": { + "unbond": { + "description": "unbond defines the unbonding information of a delegation.", + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "entries": { + "type": "array", + "items": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "balance": { + "type": "string" + } + }, + "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." + } + } + }, + "title": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list" + } + }, + "description": "QueryDelegationResponse is response type for the Query/UnbondingDelegation RPC method." + }, + "cosmos.staking.v1beta1.QueryValidatorDelegationsResponse": { + "type": "object", + "properties": { + "delegation_responses": { + "type": "array", + "items": { + "type": "object", + "properties": { + "delegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "shares": { + "type": "string" + } + }, + "description": "Delegation represents the bond with tokens held by an account. It is\nowned by one delegator, and is associated with the voting power of one\nvalidator." + }, + "balance": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + } + }, + "description": "DelegationResponse is equivalent to Delegation except that it contains a balance\nin addition to shares which is more suitable for client responses." + } + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "title": "QueryValidatorDelegationsResponse is response type for the Query/ValidatorDelegations RPC method" + }, + "cosmos.staking.v1beta1.QueryValidatorResponse": { + "type": "object", + "properties": { + "validator": { + "description": "validator defines the the validator info.", + "type": "object", + "properties": { + "operator_address": { + "type": "string", + "format": "byte" + }, + "consensus_pubkey": { + "type": "string" + }, + "jailed": { + "type": "boolean", + "format": "boolean" + }, + "status": { + "type": "integer", + "format": "int32" + }, + "tokens": { + "type": "string" + }, + "delegator_shares": { + "type": "string" + }, + "description": { + "type": "object", + "properties": { + "moniker": { + "type": "string" + }, + "identity": { + "type": "string" + }, + "website": { + "type": "string" + }, + "security_contact": { + "type": "string" + }, + "details": { + "type": "string" + } + }, + "description": "Description defines a validator description." + }, + "unbonding_height": { + "type": "string", + "format": "int64" + }, + "unbonding_time": { + "type": "string", + "format": "date-time" + }, + "commission": { + "type": "object", + "properties": { + "commission_rates": { + "type": "object", + "properties": { + "rate": { + "type": "string" + }, + "max_rate": { + "type": "string" + }, + "max_change_rate": { + "type": "string" + } + }, + "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + }, + "update_time": { + "type": "string", + "format": "date-time" + } + }, + "description": "Commission defines a commission parameters for a given validator." + }, + "min_self_delegation": { + "type": "string" + } + } + } + }, + "title": "QueryValidatorResponse is response type for the Query/Validator RPC method" + }, + "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse": { + "type": "object", + "properties": { + "unbonding_responses": { + "type": "array", + "items": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "entries": { + "type": "array", + "items": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "balance": { + "type": "string" + } + }, + "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." + } + } + }, + "title": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list" + } + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "description": "QueryValidatorUnbondingDelegationsResponse is response type for the Query/ValidatorUnbondingDelegations RPC method." + }, + "cosmos.staking.v1beta1.QueryValidatorsResponse": { + "type": "object", + "properties": { + "validators": { + "type": "array", + "items": { + "type": "object", + "properties": { + "operator_address": { + "type": "string", + "format": "byte" + }, + "consensus_pubkey": { + "type": "string" + }, + "jailed": { + "type": "boolean", + "format": "boolean" + }, + "status": { + "type": "integer", + "format": "int32" + }, + "tokens": { + "type": "string" + }, + "delegator_shares": { + "type": "string" + }, + "description": { + "type": "object", + "properties": { + "moniker": { + "type": "string" + }, + "identity": { + "type": "string" + }, + "website": { + "type": "string" + }, + "security_contact": { + "type": "string" + }, + "details": { + "type": "string" + } + }, + "description": "Description defines a validator description." + }, + "unbonding_height": { + "type": "string", + "format": "int64" + }, + "unbonding_time": { + "type": "string", + "format": "date-time" + }, + "commission": { + "type": "object", + "properties": { + "commission_rates": { + "type": "object", + "properties": { + "rate": { + "type": "string" + }, + "max_rate": { + "type": "string" + }, + "max_change_rate": { + "type": "string" + } + }, + "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + }, + "update_time": { + "type": "string", + "format": "date-time" + } + }, + "description": "Commission defines a commission parameters for a given validator." + }, + "min_self_delegation": { + "type": "string" + } + }, + "description": "Validator defines the total amount of bond shares and their exchange rate to\ncoins. Slashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." + }, + "description": "validators contains all the queried validators." + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } + }, + "title": "QueryValidatorsResponse is response type for the Query/Validators RPC method" + }, + "cosmos.staking.v1beta1.Redelegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_src_address": { + "type": "string", + "format": "byte" + }, + "validator_dst_address": { + "type": "string", + "format": "byte" + }, + "entries": { + "type": "array", + "items": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "shares_dst": { + "type": "string" + } + }, + "description": "RedelegationEntry defines a redelegation object with relevant metadata." + } + } + }, + "description": "Redelegation contains the list of a particular delegator's redelegating bonds\nfrom a particular source validator to a particular destination validator." + }, + "cosmos.staking.v1beta1.RedelegationEntry": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "shares_dst": { + "type": "string" + } + }, + "description": "RedelegationEntry defines a redelegation object with relevant metadata." + }, + "cosmos.staking.v1beta1.RedelegationEntryResponse": { + "type": "object", + "properties": { + "redelegation_entry": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "shares_dst": { + "type": "string" + } + }, + "description": "RedelegationEntry defines a redelegation object with relevant metadata." + }, + "balance": { + "type": "string" + } + }, + "description": "RedelegationEntryResponse is equivalent to a RedelegationEntry except that it\ncontains a balance in addition to shares which is more suitable for client\nresponses." + }, + "cosmos.staking.v1beta1.RedelegationResponse": { + "type": "object", + "properties": { + "redelegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_src_address": { + "type": "string", + "format": "byte" + }, + "validator_dst_address": { + "type": "string", + "format": "byte" + }, + "entries": { + "type": "array", + "items": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "shares_dst": { + "type": "string" + } + }, + "description": "RedelegationEntry defines a redelegation object with relevant metadata." + } + } + }, + "description": "Redelegation contains the list of a particular delegator's redelegating bonds\nfrom a particular source validator to a particular destination validator." + }, + "entries": { + "type": "array", + "items": { + "type": "object", + "properties": { + "redelegation_entry": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "shares_dst": { + "type": "string" + } + }, + "description": "RedelegationEntry defines a redelegation object with relevant metadata." + }, + "balance": { + "type": "string" + } + }, + "description": "RedelegationEntryResponse is equivalent to a RedelegationEntry except that it\ncontains a balance in addition to shares which is more suitable for client\nresponses." + } + } + }, + "description": "RedelegationResponse is equivalent to a Redelegation except that its entries\ncontain a balance in addition to shares which is more suitable for client\nresponses." + }, + "cosmos.staking.v1beta1.UnbondingDelegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "entries": { + "type": "array", + "items": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "balance": { + "type": "string" + } + }, + "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." + } + } + }, + "title": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list" + }, + "cosmos.staking.v1beta1.UnbondingDelegationEntry": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "balance": { + "type": "string" + } + }, + "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." + }, + "cosmos.staking.v1beta1.Validator": { + "type": "object", + "properties": { + "operator_address": { + "type": "string", + "format": "byte" + }, + "consensus_pubkey": { + "type": "string" + }, + "jailed": { + "type": "boolean", + "format": "boolean" + }, + "status": { + "type": "integer", + "format": "int32" + }, + "tokens": { + "type": "string" + }, + "delegator_shares": { + "type": "string" + }, + "description": { + "type": "object", + "properties": { + "moniker": { + "type": "string" + }, + "identity": { + "type": "string" + }, + "website": { + "type": "string" + }, + "security_contact": { + "type": "string" + }, + "details": { + "type": "string" + } + }, + "description": "Description defines a validator description." + }, + "unbonding_height": { + "type": "string", + "format": "int64" + }, + "unbonding_time": { + "type": "string", + "format": "date-time" + }, + "commission": { + "type": "object", + "properties": { + "commission_rates": { + "type": "object", + "properties": { + "rate": { + "type": "string" + }, + "max_rate": { + "type": "string" + }, + "max_change_rate": { + "type": "string" + } + }, + "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + }, + "update_time": { + "type": "string", + "format": "date-time" + } + }, + "description": "Commission defines a commission parameters for a given validator." + }, + "min_self_delegation": { + "type": "string" + } + }, + "description": "Validator defines the total amount of bond shares and their exchange rate to\ncoins. Slashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." + }, + "tendermint.types.BlockID": { + "type": "object", + "properties": { + "hash": { + "type": "string", + "format": "byte" + }, + "part_set_header": { + "type": "object", + "properties": { + "total": { + "type": "integer", + "format": "int64" + }, + "hash": { + "type": "string", + "format": "byte" + } + }, + "title": "PartsetHeader" + } + }, + "title": "BlockID" + }, + "tendermint.types.Header": { + "type": "object", + "properties": { + "version": { + "title": "basic block info", + "type": "object", + "properties": { + "block": { + "type": "string", + "format": "uint64" + }, + "app": { + "type": "string", + "format": "uint64" + } + }, + "description": "Consensus captures the consensus rules for processing a block in the blockchain,\nincluding all blockchain data structures and the rules of the application's\nstate transition machine." + }, + "chain_id": { + "type": "string" + }, + "height": { + "type": "string", + "format": "int64" + }, + "time": { + "type": "string", + "format": "date-time" + }, + "last_block_id": { + "title": "prev block info", + "type": "object", + "properties": { + "hash": { + "type": "string", + "format": "byte" + }, + "part_set_header": { + "type": "object", + "properties": { + "total": { + "type": "integer", + "format": "int64" + }, + "hash": { + "type": "string", + "format": "byte" + } + }, + "title": "PartsetHeader" + } + } + }, + "last_commit_hash": { + "type": "string", + "format": "byte", + "title": "hashes of block data" + }, + "data_hash": { + "type": "string", + "format": "byte" + }, + "validators_hash": { + "type": "string", + "format": "byte", + "title": "hashes from the app output from the prev block" + }, + "next_validators_hash": { + "type": "string", + "format": "byte" + }, + "consensus_hash": { + "type": "string", + "format": "byte" + }, + "app_hash": { + "type": "string", + "format": "byte" + }, + "last_results_hash": { + "type": "string", + "format": "byte" + }, + "evidence_hash": { + "type": "string", + "format": "byte", + "title": "consensus info" + }, + "proposer_address": { + "type": "string", + "format": "byte" + } + }, + "description": "Header defines the structure of a Tendermint block header." + }, + "tendermint.types.PartSetHeader": { + "type": "object", + "properties": { + "total": { + "type": "integer", + "format": "int64" + }, + "hash": { + "type": "string", + "format": "byte" + } + }, + "title": "PartsetHeader" + }, + "tendermint.version.Consensus": { + "type": "object", + "properties": { + "block": { + "type": "string", + "format": "uint64" + }, + "app": { + "type": "string", + "format": "uint64" + } + }, + "description": "Consensus captures the consensus rules for processing a block in the blockchain,\nincluding all blockchain data structures and the rules of the application's\nstate transition machine." + }, + "cosmos.upgrade.v1beta1.Plan": { + "type": "object", + "properties": { + "name": { + "type": "string", + "description": "Sets the name for the upgrade. This name will be used by the upgraded version of the software to apply any\nspecial \"on-upgrade\" commands during the first BeginBlock method after the upgrade is applied. It is also used\nto detect whether a software version can handle a given upgrade. If no upgrade handler with this name has been\nset in the software, it will be assumed that the software is out-of-date when the upgrade Time or Height\nis reached and the software will exit." + }, + "time": { + "type": "string", + "format": "date-time", + "description": "The time after which the upgrade must be performed.\nLeave set to its zero value to use a pre-defined Height instead." + }, + "height": { + "type": "string", + "format": "int64", + "description": "The height at which the upgrade must be performed.\nOnly used if Time is not set." + }, + "info": { + "type": "string", + "title": "Any application specific upgrade info to be included on-chain\nsuch as a git commit that validators could automatically upgrade to" + } + }, + "title": "Plan specifies information about a planned upgrade and when it should occur" + }, + "cosmos.upgrade.v1beta1.QueryAppliedPlanResponse": { + "type": "object", + "properties": { + "height": { + "type": "string", + "format": "int64", + "description": "height is the block height at which the plan was applied." + } + }, + "description": "QueryAppliedPlanResponse is the response type for the Query/AppliedPlan RPC method." + }, + "cosmos.upgrade.v1beta1.QueryCurrentPlanResponse": { + "type": "object", + "properties": { + "plan": { + "description": "plan is the current upgrade plan.", + "type": "object", + "properties": { + "name": { + "type": "string", + "description": "Sets the name for the upgrade. This name will be used by the upgraded version of the software to apply any\nspecial \"on-upgrade\" commands during the first BeginBlock method after the upgrade is applied. It is also used\nto detect whether a software version can handle a given upgrade. If no upgrade handler with this name has been\nset in the software, it will be assumed that the software is out-of-date when the upgrade Time or Height\nis reached and the software will exit." + }, + "time": { + "type": "string", + "format": "date-time", + "description": "The time after which the upgrade must be performed.\nLeave set to its zero value to use a pre-defined Height instead." + }, + "height": { + "type": "string", + "format": "int64", + "description": "The height at which the upgrade must be performed.\nOnly used if Time is not set." + }, + "info": { + "type": "string", + "title": "Any application specific upgrade info to be included on-chain\nsuch as a git commit that validators could automatically upgrade to" + } + }, + "title": "Plan specifies information about a planned upgrade and when it should occur" + } + }, + "description": "QueryCurrentPlanResponse is the response type for the Query/CurrentPlan RPC method." + } + } +} \ No newline at end of file diff --git a/cosmos/auth/v1beta1/query.swagger.json b/cosmos/auth/v1beta1/query.swagger.json new file mode 100644 index 000000000000..da7c339eee3a --- /dev/null +++ b/cosmos/auth/v1beta1/query.swagger.json @@ -0,0 +1,155 @@ +{ + "swagger": "2.0", + "info": { + "title": "cosmos/auth/v1beta1/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/cosmos/auth/v1beta1/accounts/{address}": { + "get": { + "summary": "Account returns account details based on address.", + "operationId": "Account", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.auth.v1beta1.QueryAccountResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "address", + "description": "address defines the address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/auth/v1beta1/params": { + "get": { + "summary": "Params queries all parameters.", + "operationId": "Params", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.auth.v1beta1.QueryParamsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "cosmos.auth.v1beta1.Params": { + "type": "object", + "properties": { + "max_memo_characters": { + "type": "string", + "format": "uint64" + }, + "tx_sig_limit": { + "type": "string", + "format": "uint64" + }, + "tx_size_cost_per_byte": { + "type": "string", + "format": "uint64" + }, + "sig_verify_cost_ed25519": { + "type": "string", + "format": "uint64" + }, + "sig_verify_cost_secp256k1": { + "type": "string", + "format": "uint64" + } + }, + "description": "Params defines the parameters for the auth module." + }, + "cosmos.auth.v1beta1.QueryAccountResponse": { + "type": "object", + "properties": { + "account": { + "$ref": "#/definitions/google.protobuf.Any", + "description": "account defines the account of the corresponding address." + } + }, + "description": "QueryAccountResponse is the response type for the Query/Account RPC method." + }, + "cosmos.auth.v1beta1.QueryParamsResponse": { + "type": "object", + "properties": { + "params": { + "$ref": "#/definitions/cosmos.auth.v1beta1.Params", + "description": "params defines the parameters of the module." + } + }, + "description": "QueryParamsResponse is the response type for the Query/Params RPC method." + }, + "google.protobuf.Any": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := \u0026pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "grpc.gateway.runtime.Error": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/google.protobuf.Any" + } + } + } + } + } +} diff --git a/cosmos/bank/v1beta1/query.swagger.json b/cosmos/bank/v1beta1/query.swagger.json new file mode 100644 index 000000000000..34c225b38e5b --- /dev/null +++ b/cosmos/bank/v1beta1/query.swagger.json @@ -0,0 +1,377 @@ +{ + "swagger": "2.0", + "info": { + "title": "cosmos/bank/v1beta1/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/cosmos/bank/v1beta1/balances/{address}": { + "get": { + "summary": "AllBalances queries the balance of all coins for a single account.", + "operationId": "AllBalances", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.bank.v1beta1.QueryAllBalancesResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "address", + "description": "address is the address to query balances for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/bank/v1beta1/balances/{address}/{denom}": { + "get": { + "summary": "Balance queries the balance of a single coin for a single account.", + "operationId": "Balance", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.bank.v1beta1.QueryBalanceResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "address", + "description": "address is the address to query balances for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "denom", + "description": "denom is the coin denom to query balances for.", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/bank/v1beta1/params": { + "get": { + "summary": "Params queries the parameters of x/bank module.", + "operationId": "Params", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.bank.v1beta1.QueryParamsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/bank/v1beta1/supply": { + "get": { + "summary": "TotalSupply queries the total supply of all coins.", + "operationId": "TotalSupply", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.bank.v1beta1.QueryTotalSupplyResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/bank/v1beta1/supply/{denom}": { + "get": { + "summary": "SupplyOf queries the supply of a single coin.", + "operationId": "SupplyOf", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.bank.v1beta1.QuerySupplyOfResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "denom", + "description": "denom is the coin denom to query balances for.", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "cosmos.bank.v1beta1.Params": { + "type": "object", + "properties": { + "send_enabled": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.bank.v1beta1.SendEnabled" + } + }, + "default_send_enabled": { + "type": "boolean", + "format": "boolean" + } + }, + "description": "Params defines the set of bank parameters." + }, + "cosmos.bank.v1beta1.QueryAllBalancesResponse": { + "type": "object", + "properties": { + "balances": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.base.v1beta1.Coin" + }, + "description": "balances is the balances of all the coins." + }, + "pagination": { + "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryAllBalancesResponse is the response type for the Query/AllBalances RPC method." + }, + "cosmos.bank.v1beta1.QueryBalanceResponse": { + "type": "object", + "properties": { + "balance": { + "$ref": "#/definitions/cosmos.base.v1beta1.Coin", + "description": "balance is the balance of the coin." + } + }, + "description": "QueryBalanceResponse is the response type for the Query/Balance RPC method." + }, + "cosmos.bank.v1beta1.QueryParamsResponse": { + "type": "object", + "properties": { + "params": { + "$ref": "#/definitions/cosmos.bank.v1beta1.Params" + } + }, + "description": "QueryParamsResponse defines the response type for querying x/bank parameters." + }, + "cosmos.bank.v1beta1.QuerySupplyOfResponse": { + "type": "object", + "properties": { + "amount": { + "$ref": "#/definitions/cosmos.base.v1beta1.Coin", + "description": "amount is the supply of the coin." + } + }, + "description": "QuerySupplyOfResponse is the response type for the Query/SupplyOf RPC method." + }, + "cosmos.bank.v1beta1.QueryTotalSupplyResponse": { + "type": "object", + "properties": { + "supply": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.base.v1beta1.Coin" + }, + "title": "supply is the supply of the coins" + } + }, + "title": "QueryTotalSupplyResponse is the response type for the Query/TotalSupply RPC method" + }, + "cosmos.bank.v1beta1.SendEnabled": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "enabled": { + "type": "boolean", + "format": "boolean" + } + }, + "title": "Send enabled configuration properties for each denomination" + }, + "cosmos.base.query.v1beta1.PageRequest": { + "type": "object", + "properties": { + "key": { + "type": "string", + "format": "byte", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." + }, + "offset": { + "type": "string", + "format": "uint64", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." + }, + "limit": { + "type": "string", + "format": "uint64", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." + }, + "count_total": { + "type": "boolean", + "format": "boolean", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." + } + }, + "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", + "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" + }, + "cosmos.base.query.v1beta1.PageResponse": { + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + }, + "cosmos.base.v1beta1.Coin": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + }, + "google.protobuf.Any": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + }, + "grpc.gateway.runtime.Error": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/google.protobuf.Any" + } + } + } + } + } +} diff --git a/cosmos/distribution/v1beta1/query.swagger.json b/cosmos/distribution/v1beta1/query.swagger.json new file mode 100644 index 000000000000..5980fcd4548a --- /dev/null +++ b/cosmos/distribution/v1beta1/query.swagger.json @@ -0,0 +1,628 @@ +{ + "swagger": "2.0", + "info": { + "title": "cosmos/distribution/v1beta1/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/cosmos/distribution/v1beta1/community_pool": { + "get": { + "summary": "CommunityPool queries the community pool coins.", + "operationId": "CommunityPool", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.distribution.v1beta1.QueryCommunityPoolResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards": { + "get": { + "summary": "DelegationTotalRewards queries the total rewards accrued by a each validator.", + "operationId": "DelegationTotalRewards", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.distribution.v1beta1.QueryDelegationTotalRewardsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "delegator_address", + "description": "delegator_address defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards/{validator_address}": { + "get": { + "summary": "DelegationRewards queries the total rewards accrued by a delegation.", + "operationId": "DelegationRewards", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.distribution.v1beta1.QueryDelegationRewardsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "delegator_address", + "description": "delegator_address defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "validator_address", + "description": "validator_address defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/delegators/{delegator_address}/validators": { + "get": { + "summary": "DelegatorValidators queries the validators of a delegator.", + "operationId": "DelegatorValidators", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.distribution.v1beta1.QueryDelegatorValidatorsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "delegator_address", + "description": "delegator_address defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/delegators/{delegator_address}/withdraw_address": { + "get": { + "summary": "DelegatorWithdrawAddress queries withdraw address of a delegator.", + "operationId": "DelegatorWithdrawAddress", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.distribution.v1beta1.QueryDelegatorWithdrawAddressResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "delegator_address", + "description": "delegator_address defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/params": { + "get": { + "summary": "Params queries params of the distribution module.", + "operationId": "Params", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.distribution.v1beta1.QueryParamsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/validators/{validator_address}/commission": { + "get": { + "summary": "ValidatorCommission queries accumulated commission for a validator.", + "operationId": "ValidatorCommission", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.distribution.v1beta1.QueryValidatorCommissionResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "validator_address", + "description": "validator_address defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/validators/{validator_address}/outstanding_rewards": { + "get": { + "summary": "ValidatorOutstandingRewards queries rewards of a validator address.", + "operationId": "ValidatorOutstandingRewards", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.distribution.v1beta1.QueryValidatorOutstandingRewardsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "validator_address", + "description": "validator_address defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/distribution/v1beta1/validators/{validator_address}/slashes": { + "get": { + "summary": "ValidatorSlashes queries slash events of a validator.", + "operationId": "ValidatorSlashes", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.distribution.v1beta1.QueryValidatorSlashesResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "validator_address", + "description": "validator_address defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "starting_height", + "description": "starting_height defines the optional starting height to query the slashes.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "ending_height", + "description": "starting_height defines the optional ending height to query the slashes.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "cosmos.base.query.v1beta1.PageRequest": { + "type": "object", + "properties": { + "key": { + "type": "string", + "format": "byte", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." + }, + "offset": { + "type": "string", + "format": "uint64", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." + }, + "limit": { + "type": "string", + "format": "uint64", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." + }, + "count_total": { + "type": "boolean", + "format": "boolean", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." + } + }, + "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", + "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" + }, + "cosmos.base.query.v1beta1.PageResponse": { + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + }, + "cosmos.base.v1beta1.DecCoin": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "DecCoin defines a token with a denomination and a decimal amount.\n\nNOTE: The amount field is an Dec which implements the custom method\nsignatures required by gogoproto." + }, + "cosmos.distribution.v1beta1.DelegationDelegatorReward": { + "type": "object", + "properties": { + "validator_address": { + "type": "string", + "format": "byte" + }, + "reward": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.base.v1beta1.DecCoin" + } + } + }, + "description": "DelegationDelegatorReward defines the properties\nof a delegator's delegation reward." + }, + "cosmos.distribution.v1beta1.Params": { + "type": "object", + "properties": { + "community_tax": { + "type": "string" + }, + "base_proposer_reward": { + "type": "string" + }, + "bonus_proposer_reward": { + "type": "string" + }, + "withdraw_addr_enabled": { + "type": "boolean", + "format": "boolean" + } + }, + "description": "Params defines the set of distribution parameters." + }, + "cosmos.distribution.v1beta1.QueryCommunityPoolResponse": { + "type": "object", + "properties": { + "pool": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.base.v1beta1.DecCoin" + }, + "description": "pool defines community pool's coins." + } + }, + "description": "QueryCommunityPoolResponse is the response type for the Query/CommunityPool RPC method." + }, + "cosmos.distribution.v1beta1.QueryDelegationRewardsResponse": { + "type": "object", + "properties": { + "rewards": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.base.v1beta1.DecCoin" + }, + "description": "rewards defines the rewards accrued by a delegation." + } + }, + "description": "QueryDelegationRewardsResponse is the response type for the Query/DelegationRewards RPC method." + }, + "cosmos.distribution.v1beta1.QueryDelegationTotalRewardsResponse": { + "type": "object", + "properties": { + "rewards": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.distribution.v1beta1.DelegationDelegatorReward" + }, + "description": "rewards defines all the rewards accrued by a delegator." + }, + "total": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.base.v1beta1.DecCoin" + }, + "description": "total defines the sum of all the rewards." + } + }, + "description": "QueryDelegationTotalRewardsResponse is the response type for the Query/DelegationTotalRewards RPC method." + }, + "cosmos.distribution.v1beta1.QueryDelegatorValidatorsResponse": { + "type": "object", + "properties": { + "validators": { + "type": "array", + "items": { + "type": "string", + "format": "byte" + }, + "description": "validators defines the validators a delegator is delegating for." + } + }, + "description": "QueryDelegatorValidatorsResponse is the response type for the Query/DelegatorValidators RPC method." + }, + "cosmos.distribution.v1beta1.QueryDelegatorWithdrawAddressResponse": { + "type": "object", + "properties": { + "withdraw_address": { + "type": "string", + "format": "byte", + "description": "withdraw_address defines the delegator address to query for." + } + }, + "description": "QueryDelegatorWithdrawAddressResponse is the response type for the Query/DelegatorWithdrawAddress RPC method." + }, + "cosmos.distribution.v1beta1.QueryParamsResponse": { + "type": "object", + "properties": { + "params": { + "$ref": "#/definitions/cosmos.distribution.v1beta1.Params", + "description": "params defines the parameters of the module." + } + }, + "description": "QueryParamsResponse is the response type for the Query/Params RPC method." + }, + "cosmos.distribution.v1beta1.QueryValidatorCommissionResponse": { + "type": "object", + "properties": { + "commission": { + "$ref": "#/definitions/cosmos.distribution.v1beta1.ValidatorAccumulatedCommission", + "description": "commission defines the commision the validator received." + } + }, + "title": "QueryValidatorCommissionResponse is the response type for the Query/ValidatorCommission RPC method" + }, + "cosmos.distribution.v1beta1.QueryValidatorOutstandingRewardsResponse": { + "type": "object", + "properties": { + "rewards": { + "$ref": "#/definitions/cosmos.distribution.v1beta1.ValidatorOutstandingRewards" + } + }, + "description": "QueryValidatorOutstandingRewardsResponse is the response type for the Query/ValidatorOutstandingRewards RPC method." + }, + "cosmos.distribution.v1beta1.QueryValidatorSlashesResponse": { + "type": "object", + "properties": { + "slashes": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.distribution.v1beta1.ValidatorSlashEvent" + }, + "description": "slashes defines the slashes the validator received." + }, + "pagination": { + "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryValidatorSlashesResponse is the response type for the Query/ValidatorSlashes RPC method." + }, + "cosmos.distribution.v1beta1.ValidatorAccumulatedCommission": { + "type": "object", + "properties": { + "commission": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.base.v1beta1.DecCoin" + } + } + }, + "title": "accumulated commission for a validator\nkept as a running counter, can be withdrawn at any time" + }, + "cosmos.distribution.v1beta1.ValidatorOutstandingRewards": { + "type": "object", + "properties": { + "rewards": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.base.v1beta1.DecCoin" + } + } + }, + "title": "outstanding (un-withdrawn) rewards for a validator\ninexpensive to track, allows simple sanity checks" + }, + "cosmos.distribution.v1beta1.ValidatorSlashEvent": { + "type": "object", + "properties": { + "validator_period": { + "type": "string", + "format": "uint64" + }, + "fraction": { + "type": "string" + } + }, + "title": "validator slash event\nheight is implicit within the store key\nneeded to calculate appropriate amounts of staking token\nfor delegations which withdraw after a slash has occurred" + }, + "google.protobuf.Any": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + }, + "grpc.gateway.runtime.Error": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/google.protobuf.Any" + } + } + } + } + } +} diff --git a/cosmos/evidence/v1beta1/query.swagger.json b/cosmos/evidence/v1beta1/query.swagger.json new file mode 100644 index 000000000000..1a23078b1aad --- /dev/null +++ b/cosmos/evidence/v1beta1/query.swagger.json @@ -0,0 +1,214 @@ +{ + "swagger": "2.0", + "info": { + "title": "cosmos/evidence/v1beta1/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/cosmos/evidence/v1beta1/evidence": { + "get": { + "summary": "AllEvidence queries all evidence.", + "operationId": "AllEvidence", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.evidence.v1beta1.QueryAllEvidenceResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/evidence/v1beta1/evidence/{evidence_hash}": { + "get": { + "summary": "Evidence queries evidence based on evidence hash.", + "operationId": "Evidence", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.evidence.v1beta1.QueryEvidenceResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "evidence_hash", + "description": "evidence_hash defines the hash of the requested evidence.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "cosmos.base.query.v1beta1.PageRequest": { + "type": "object", + "properties": { + "key": { + "type": "string", + "format": "byte", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." + }, + "offset": { + "type": "string", + "format": "uint64", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." + }, + "limit": { + "type": "string", + "format": "uint64", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." + }, + "count_total": { + "type": "boolean", + "format": "boolean", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." + } + }, + "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", + "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" + }, + "cosmos.base.query.v1beta1.PageResponse": { + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + }, + "cosmos.evidence.v1beta1.QueryAllEvidenceResponse": { + "type": "object", + "properties": { + "evidence": { + "type": "array", + "items": { + "$ref": "#/definitions/google.protobuf.Any" + }, + "description": "evidence returns all evidences." + }, + "pagination": { + "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryAllEvidenceResponse is the response type for the Query/AllEvidence RPC method." + }, + "cosmos.evidence.v1beta1.QueryEvidenceResponse": { + "type": "object", + "properties": { + "evidence": { + "$ref": "#/definitions/google.protobuf.Any", + "description": "evidence returns the requested evidence." + } + }, + "description": "QueryEvidenceResponse is the response type for the Query/Evidence RPC method." + }, + "google.protobuf.Any": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := \u0026pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "grpc.gateway.runtime.Error": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/google.protobuf.Any" + } + } + } + } + } +} diff --git a/cosmos/gov/v1beta1/query.swagger.json b/cosmos/gov/v1beta1/query.swagger.json new file mode 100644 index 000000000000..dc560b8ab4e0 --- /dev/null +++ b/cosmos/gov/v1beta1/query.swagger.json @@ -0,0 +1,785 @@ +{ + "swagger": "2.0", + "info": { + "title": "cosmos/gov/v1beta1/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/cosmos/gov/v1beta1/params/{params_type}": { + "get": { + "summary": "Params queries all parameters of the gov module.", + "operationId": "Params", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.gov.v1beta1.QueryParamsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "params_type", + "description": "params_type defines which parameters to query for, can be one of \"voting\", \"tallying\" or \"deposit\".", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/gov/v1beta1/proposals": { + "get": { + "summary": "Proposals queries all proposals based on given status.", + "operationId": "Proposals", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.gov.v1beta1.QueryProposalsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "proposal_status", + "description": "proposal_status defines the status of the proposals.\n\n - PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed.", + "in": "query", + "required": false, + "type": "string", + "enum": [ + "PROPOSAL_STATUS_UNSPECIFIED", + "PROPOSAL_STATUS_DEPOSIT_PERIOD", + "PROPOSAL_STATUS_VOTING_PERIOD", + "PROPOSAL_STATUS_PASSED", + "PROPOSAL_STATUS_REJECTED", + "PROPOSAL_STATUS_FAILED" + ], + "default": "PROPOSAL_STATUS_UNSPECIFIED" + }, + { + "name": "voter", + "description": "voter defines the voter address for the proposals.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "depositor", + "description": "depositor defines the deposit addresses from the proposals.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/gov/v1beta1/proposals/{proposal_id}": { + "get": { + "summary": "Proposal queries proposal details based on ProposalID.", + "operationId": "Proposal", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.gov.v1beta1.QueryProposalResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "proposal_id", + "description": "proposal_id defines the unique id of the proposal.", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/gov/v1beta1/proposals/{proposal_id}/deposits": { + "get": { + "summary": "Deposits queries all deposits of a single proposal.", + "operationId": "Deposits", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.gov.v1beta1.QueryDepositsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "proposal_id", + "description": "proposal_id defines the unique id of the proposal.", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/gov/v1beta1/proposals/{proposal_id}/deposits/{depositor}": { + "get": { + "summary": "Deposit queries single deposit information based proposalID, depositAddr.", + "operationId": "Deposit", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.gov.v1beta1.QueryDepositResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "proposal_id", + "description": "proposal_id defines the unique id of the proposal.", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + }, + { + "name": "depositor", + "description": "depositor defines the deposit addresses from the proposals.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/gov/v1beta1/proposals/{proposal_id}/tally": { + "get": { + "summary": "TallyResult queries the tally of a proposal vote.", + "operationId": "TallyResult", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.gov.v1beta1.QueryTallyResultResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "proposal_id", + "description": "proposal_id defines the unique id of the proposal.", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/gov/v1beta1/proposals/{proposal_id}/votes": { + "get": { + "summary": "Votes queries votes of a given proposal.", + "operationId": "Votes", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.gov.v1beta1.QueryVotesResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "proposal_id", + "description": "proposal_id defines the unique id of the proposal.", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/gov/v1beta1/proposals/{proposal_id}/votes/{voter}": { + "get": { + "summary": "Vote queries voted information based on proposalID, voterAddr.", + "operationId": "Vote", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.gov.v1beta1.QueryVoteResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "proposal_id", + "description": "proposal_id defines the unique id of the proposal.", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + }, + { + "name": "voter", + "description": "voter defines the oter address for the proposals.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "cosmos.base.query.v1beta1.PageRequest": { + "type": "object", + "properties": { + "key": { + "type": "string", + "format": "byte", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." + }, + "offset": { + "type": "string", + "format": "uint64", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." + }, + "limit": { + "type": "string", + "format": "uint64", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." + }, + "count_total": { + "type": "boolean", + "format": "boolean", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." + } + }, + "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", + "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" + }, + "cosmos.base.query.v1beta1.PageResponse": { + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + }, + "cosmos.base.v1beta1.Coin": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + }, + "cosmos.gov.v1beta1.Deposit": { + "type": "object", + "properties": { + "proposal_id": { + "type": "string", + "format": "uint64" + }, + "depositor": { + "type": "string", + "format": "byte" + }, + "amount": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.base.v1beta1.Coin" + } + } + }, + "title": "Deposit defines an amount deposited by an account address to an active proposal" + }, + "cosmos.gov.v1beta1.DepositParams": { + "type": "object", + "properties": { + "min_deposit": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.base.v1beta1.Coin" + }, + "description": "Minimum deposit for a proposal to enter voting period." + }, + "max_deposit_period": { + "type": "string", + "description": "Maximum period for Atom holders to deposit on a proposal. Initial value: 2 months." + } + }, + "title": "DepositParams defines the params around deposits for governance" + }, + "cosmos.gov.v1beta1.Proposal": { + "type": "object", + "properties": { + "proposal_id": { + "type": "string", + "format": "uint64" + }, + "content": { + "$ref": "#/definitions/google.protobuf.Any" + }, + "status": { + "$ref": "#/definitions/cosmos.gov.v1beta1.ProposalStatus" + }, + "final_tally_result": { + "$ref": "#/definitions/cosmos.gov.v1beta1.TallyResult" + }, + "submit_time": { + "type": "string", + "format": "date-time" + }, + "deposit_end_time": { + "type": "string", + "format": "date-time" + }, + "total_deposit": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.base.v1beta1.Coin" + } + }, + "voting_start_time": { + "type": "string", + "format": "date-time" + }, + "voting_end_time": { + "type": "string", + "format": "date-time" + } + }, + "title": "Proposal defines the core field members of a governance proposal" + }, + "cosmos.gov.v1beta1.ProposalStatus": { + "type": "string", + "enum": [ + "PROPOSAL_STATUS_UNSPECIFIED", + "PROPOSAL_STATUS_DEPOSIT_PERIOD", + "PROPOSAL_STATUS_VOTING_PERIOD", + "PROPOSAL_STATUS_PASSED", + "PROPOSAL_STATUS_REJECTED", + "PROPOSAL_STATUS_FAILED" + ], + "default": "PROPOSAL_STATUS_UNSPECIFIED", + "description": "- PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed.", + "title": "ProposalStatus is a type alias that represents a proposal status as a byte" + }, + "cosmos.gov.v1beta1.QueryDepositResponse": { + "type": "object", + "properties": { + "deposit": { + "$ref": "#/definitions/cosmos.gov.v1beta1.Deposit", + "description": "deposit defines the requested deposit." + } + }, + "description": "QueryDepositResponse is the response type for the Query/Deposit RPC method." + }, + "cosmos.gov.v1beta1.QueryDepositsResponse": { + "type": "object", + "properties": { + "deposits": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.gov.v1beta1.Deposit" + } + }, + "pagination": { + "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryDepositsResponse is the response type for the Query/Deposits RPC method." + }, + "cosmos.gov.v1beta1.QueryParamsResponse": { + "type": "object", + "properties": { + "voting_params": { + "$ref": "#/definitions/cosmos.gov.v1beta1.VotingParams", + "description": "voting_params defines the parameters related to voting." + }, + "deposit_params": { + "$ref": "#/definitions/cosmos.gov.v1beta1.DepositParams", + "description": "deposit_params defines the parameters related to deposit." + }, + "tally_params": { + "$ref": "#/definitions/cosmos.gov.v1beta1.TallyParams", + "description": "tally_params defines the parameters related to tally." + } + }, + "description": "QueryParamsResponse is the response type for the Query/Params RPC method." + }, + "cosmos.gov.v1beta1.QueryProposalResponse": { + "type": "object", + "properties": { + "proposal": { + "$ref": "#/definitions/cosmos.gov.v1beta1.Proposal" + } + }, + "description": "QueryProposalResponse is the response type for the Query/Proposal RPC method." + }, + "cosmos.gov.v1beta1.QueryProposalsResponse": { + "type": "object", + "properties": { + "proposals": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.gov.v1beta1.Proposal" + } + }, + "pagination": { + "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryProposalsResponse is the response type for the Query/Proposals RPC method." + }, + "cosmos.gov.v1beta1.QueryTallyResultResponse": { + "type": "object", + "properties": { + "tally": { + "$ref": "#/definitions/cosmos.gov.v1beta1.TallyResult", + "description": "tally defines the requested tally." + } + }, + "description": "QueryTallyResultResponse is the response type for the Query/Tally RPC method." + }, + "cosmos.gov.v1beta1.QueryVoteResponse": { + "type": "object", + "properties": { + "vote": { + "$ref": "#/definitions/cosmos.gov.v1beta1.Vote", + "description": "vote defined the queried vote." + } + }, + "description": "QueryVoteResponse is the response type for the Query/Vote RPC method." + }, + "cosmos.gov.v1beta1.QueryVotesResponse": { + "type": "object", + "properties": { + "votes": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.gov.v1beta1.Vote" + }, + "description": "votes defined the queried votes." + }, + "pagination": { + "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryVotesResponse is the response type for the Query/Votes RPC method." + }, + "cosmos.gov.v1beta1.TallyParams": { + "type": "object", + "properties": { + "quorum": { + "type": "string", + "format": "byte", + "description": "Minimum percentage of total stake needed to vote for a result to be considered valid." + }, + "threshold": { + "type": "string", + "format": "byte", + "description": "Minimum proportion of Yes votes for proposal to pass. Initial value: 0.5." + }, + "veto": { + "type": "string", + "format": "byte", + "description": "Minimum value of Veto votes to Total votes ratio for proposal to be vetoed. Initial value: 1/3." + } + }, + "title": "TallyParams defines the params around Tallying votes in governance" + }, + "cosmos.gov.v1beta1.TallyResult": { + "type": "object", + "properties": { + "yes": { + "type": "string" + }, + "abstain": { + "type": "string" + }, + "no": { + "type": "string" + }, + "no_with_veto": { + "type": "string" + } + }, + "title": "TallyResult defines a standard tally for a proposal" + }, + "cosmos.gov.v1beta1.Vote": { + "type": "object", + "properties": { + "proposal_id": { + "type": "string", + "format": "uint64" + }, + "voter": { + "type": "string", + "format": "byte" + }, + "option": { + "$ref": "#/definitions/cosmos.gov.v1beta1.VoteOption" + } + }, + "description": "Vote defines a vote on a governance proposal. A vote corresponds to a proposal\nID, the voter, and the vote option." + }, + "cosmos.gov.v1beta1.VoteOption": { + "type": "string", + "enum": [ + "VOTE_OPTION_UNSPECIFIED", + "VOTE_OPTION_YES", + "VOTE_OPTION_ABSTAIN", + "VOTE_OPTION_NO", + "VOTE_OPTION_NO_WITH_VETO" + ], + "default": "VOTE_OPTION_UNSPECIFIED", + "description": "- VOTE_OPTION_UNSPECIFIED: VOTE_OPTION_UNSPECIFIED defines a no-op vote option.\n - VOTE_OPTION_YES: VOTE_OPTION_YES defines a yes vote option.\n - VOTE_OPTION_ABSTAIN: VOTE_OPTION_ABSTAIN defines an abstain vote option.\n - VOTE_OPTION_NO: VOTE_OPTION_NO defines a no vote option.\n - VOTE_OPTION_NO_WITH_VETO: VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option.", + "title": "VoteOption defines a vote option" + }, + "cosmos.gov.v1beta1.VotingParams": { + "type": "object", + "properties": { + "voting_period": { + "type": "string", + "description": "Length of the voting period." + } + }, + "title": "VotingParams defines the params around Voting in governance" + }, + "google.protobuf.Any": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := \u0026pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "grpc.gateway.runtime.Error": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/google.protobuf.Any" + } + } + } + } + } +} diff --git a/cosmos/mint/v1beta1/query.swagger.json b/cosmos/mint/v1beta1/query.swagger.json new file mode 100644 index 000000000000..ccaafc8931d2 --- /dev/null +++ b/cosmos/mint/v1beta1/query.swagger.json @@ -0,0 +1,182 @@ +{ + "swagger": "2.0", + "info": { + "title": "cosmos/mint/v1beta1/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/cosmos/mint/v1beta1/annual_provisions": { + "get": { + "summary": "AnnualProvisions current minting annual provisions value.", + "operationId": "AnnualProvisions", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.mint.v1beta1.QueryAnnualProvisionsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/mint/v1beta1/inflation": { + "get": { + "summary": "Inflation returns the current minting inflation value.", + "operationId": "Inflation", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.mint.v1beta1.QueryInflationResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/mint/v1beta1/params": { + "get": { + "summary": "Params returns the total set of minting parameters.", + "operationId": "Params", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.mint.v1beta1.QueryParamsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "cosmos.mint.v1beta1.Params": { + "type": "object", + "properties": { + "mint_denom": { + "type": "string", + "title": "type of coin to mint" + }, + "inflation_rate_change": { + "type": "string", + "title": "maximum annual change in inflation rate" + }, + "inflation_max": { + "type": "string", + "title": "maximum inflation rate" + }, + "inflation_min": { + "type": "string", + "title": "minimum inflation rate" + }, + "goal_bonded": { + "type": "string", + "title": "goal of percent bonded atoms" + }, + "blocks_per_year": { + "type": "string", + "format": "uint64", + "title": "expected blocks per year" + } + }, + "title": "mint parameters" + }, + "cosmos.mint.v1beta1.QueryAnnualProvisionsResponse": { + "type": "object", + "properties": { + "annual_provisions": { + "type": "string", + "format": "byte", + "description": "annual_provisions is the current minting annual provisions value." + } + }, + "description": "QueryAnnualProvisionsResponse is the response type for the Query/AnnualProvisions RPC method." + }, + "cosmos.mint.v1beta1.QueryInflationResponse": { + "type": "object", + "properties": { + "inflation": { + "type": "string", + "format": "byte", + "description": "inflation is the current minting inflation value." + } + }, + "description": "QueryInflationResponse is the response type for the Query/Inflation RPC method." + }, + "cosmos.mint.v1beta1.QueryParamsResponse": { + "type": "object", + "properties": { + "params": { + "$ref": "#/definitions/cosmos.mint.v1beta1.Params", + "description": "params defines the parameters of the module." + } + }, + "description": "QueryParamsResponse is the response type for the Query/Params RPC method." + }, + "google.protobuf.Any": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + }, + "grpc.gateway.runtime.Error": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/google.protobuf.Any" + } + } + } + } + } +} diff --git a/cosmos/params/v1beta1/query.swagger.json b/cosmos/params/v1beta1/query.swagger.json new file mode 100644 index 000000000000..6d2444ad07d1 --- /dev/null +++ b/cosmos/params/v1beta1/query.swagger.json @@ -0,0 +1,114 @@ +{ + "swagger": "2.0", + "info": { + "title": "cosmos/params/v1beta1/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/cosmos/params/v1beta1/params": { + "get": { + "summary": "Params queries a specific parameter of a module, given its subspace and key.", + "operationId": "Params", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.params.v1beta1.QueryParamsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "subspace", + "description": "subspace defines the module to query the parameter for.", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "key", + "description": "key defines the key of the parameter in the subspace.", + "in": "query", + "required": false, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "cosmos.params.v1beta1.ParamChange": { + "type": "object", + "properties": { + "subspace": { + "type": "string" + }, + "key": { + "type": "string" + }, + "value": { + "type": "string" + } + }, + "description": "ParamChange defines a parameter change." + }, + "cosmos.params.v1beta1.QueryParamsResponse": { + "type": "object", + "properties": { + "param": { + "$ref": "#/definitions/cosmos.params.v1beta1.ParamChange", + "description": "param defines the queried parameter." + } + }, + "description": "QueryParamsResponse is response type for the Query/Params RPC method." + }, + "google.protobuf.Any": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + }, + "grpc.gateway.runtime.Error": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/google.protobuf.Any" + } + } + } + } + } +} diff --git a/cosmos/slashing/v1beta1/query.swagger.json b/cosmos/slashing/v1beta1/query.swagger.json new file mode 100644 index 000000000000..d3e0c9dd9239 --- /dev/null +++ b/cosmos/slashing/v1beta1/query.swagger.json @@ -0,0 +1,302 @@ +{ + "swagger": "2.0", + "info": { + "title": "cosmos/slashing/v1beta1/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/cosmos/slashing/v1beta1/params": { + "get": { + "summary": "Params queries the parameters of slashing module", + "operationId": "Params", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.slashing.v1beta1.QueryParamsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/slashing/v1beta1/signing_infos": { + "get": { + "summary": "SigningInfos queries signing info of all validators", + "operationId": "SigningInfos", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.slashing.v1beta1.QuerySigningInfosResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/slashing/v1beta1/signing_infos/{cons_address}": { + "get": { + "summary": "SigningInfo queries the signing info of given cons address", + "operationId": "SigningInfo", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.slashing.v1beta1.QuerySigningInfoResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "cons_address", + "description": "cons_address is the address to query signing info of", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "cosmos.base.query.v1beta1.PageRequest": { + "type": "object", + "properties": { + "key": { + "type": "string", + "format": "byte", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." + }, + "offset": { + "type": "string", + "format": "uint64", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." + }, + "limit": { + "type": "string", + "format": "uint64", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." + }, + "count_total": { + "type": "boolean", + "format": "boolean", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." + } + }, + "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", + "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" + }, + "cosmos.base.query.v1beta1.PageResponse": { + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + }, + "cosmos.slashing.v1beta1.Params": { + "type": "object", + "properties": { + "signed_blocks_window": { + "type": "string", + "format": "int64" + }, + "min_signed_per_window": { + "type": "string", + "format": "byte" + }, + "downtime_jail_duration": { + "type": "string" + }, + "slash_fraction_double_sign": { + "type": "string", + "format": "byte" + }, + "slash_fraction_downtime": { + "type": "string", + "format": "byte" + } + }, + "title": "Params - used for initializing default parameter for slashing at genesis" + }, + "cosmos.slashing.v1beta1.QueryParamsResponse": { + "type": "object", + "properties": { + "params": { + "$ref": "#/definitions/cosmos.slashing.v1beta1.Params" + } + }, + "title": "QueryParamsResponse is the response type for the Query/Params RPC method" + }, + "cosmos.slashing.v1beta1.QuerySigningInfoResponse": { + "type": "object", + "properties": { + "val_signing_info": { + "$ref": "#/definitions/cosmos.slashing.v1beta1.ValidatorSigningInfo", + "title": "val_signing_info is the signing info of requested val cons address" + } + }, + "title": "QuerySigningInfoResponse is the response type for the Query/SigningInfo RPC method" + }, + "cosmos.slashing.v1beta1.QuerySigningInfosResponse": { + "type": "object", + "properties": { + "info": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.slashing.v1beta1.ValidatorSigningInfo" + }, + "title": "info is the signing info of all validators" + }, + "pagination": { + "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse" + } + }, + "title": "QuerySigningInfosResponse is the response type for the Query/SigningInfos RPC method" + }, + "cosmos.slashing.v1beta1.ValidatorSigningInfo": { + "type": "object", + "properties": { + "address": { + "type": "string", + "format": "byte" + }, + "start_height": { + "type": "string", + "format": "int64", + "title": "height at which validator was first a candidate OR was unjailed" + }, + "index_offset": { + "type": "string", + "format": "int64", + "title": "index offset into signed block bit array" + }, + "jailed_until": { + "type": "string", + "format": "date-time", + "title": "timestamp validator cannot be unjailed until" + }, + "tombstoned": { + "type": "boolean", + "format": "boolean", + "title": "whether or not a validator has been tombstoned (killed out of validator set)" + }, + "missed_blocks_counter": { + "type": "string", + "format": "int64", + "title": "missed blocks counter (to avoid scanning the array every time)" + } + }, + "title": "ValidatorSigningInfo defines the signing info for a validator" + }, + "google.protobuf.Any": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + }, + "grpc.gateway.runtime.Error": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/google.protobuf.Any" + } + } + } + } + } +} diff --git a/cosmos/staking/v1beta1/query.swagger.json b/cosmos/staking/v1beta1/query.swagger.json new file mode 100644 index 000000000000..b34a1bc9b5df --- /dev/null +++ b/cosmos/staking/v1beta1/query.swagger.json @@ -0,0 +1,1385 @@ +{ + "swagger": "2.0", + "info": { + "title": "cosmos/staking/v1beta1/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/cosmos/staking/v1beta1/delegations/{delegator_addr}": { + "get": { + "summary": "DelegatorDelegations queries all delegations of a given delegator address.", + "operationId": "DelegatorDelegations", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "delegator_addr", + "description": "delegator_addr defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/delegators/{delegator_addr}/redelegations": { + "get": { + "summary": "Redelegations queries redelegations of given address.", + "operationId": "Redelegations", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.staking.v1beta1.QueryRedelegationsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "delegator_addr", + "description": "delegator_addr defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "src_validator_addr", + "description": "src_validator_addr defines the validator address to redelegate from.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "dst_validator_addr", + "description": "dst_validator_addr defines the validator address to redelegate to.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/delegators/{delegator_addr}/unbonding_delegations": { + "get": { + "summary": "DelegatorUnbondingDelegations queries all unbonding delegations of a given delegator address.", + "operationId": "DelegatorUnbondingDelegations", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "delegator_addr", + "description": "delegator_addr defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators": { + "get": { + "summary": "DelegatorValidators queries all validators info for given delegator address.", + "operationId": "DelegatorValidators", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "delegator_addr", + "description": "delegator_addr defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators/{validator_addr}": { + "get": { + "summary": "DelegatorValidator queries validator info for given delegator validator pair.", + "operationId": "DelegatorValidator", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.staking.v1beta1.QueryDelegatorValidatorResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "delegator_addr", + "description": "delegator_addr defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "validator_addr", + "description": "validator_addr defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/historical_info/{height}": { + "get": { + "summary": "HistoricalInfo queries the historical info for given height.", + "operationId": "HistoricalInfo", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.staking.v1beta1.QueryHistoricalInfoResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "height", + "description": "height defines at which height to query the historical info.", + "in": "path", + "required": true, + "type": "string", + "format": "int64" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/params": { + "get": { + "summary": "Parameters queries the staking parameters.", + "operationId": "Params", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.staking.v1beta1.QueryParamsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/pool": { + "get": { + "summary": "Pool queries the pool info.", + "operationId": "Pool", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.staking.v1beta1.QueryPoolResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/validators": { + "get": { + "summary": "Validators queries all validators that match the given status.", + "operationId": "Validators", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.staking.v1beta1.QueryValidatorsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "status", + "description": "status enables to query for validators matching a given status.", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/validators/{validator_addr}": { + "get": { + "summary": "Validator queries validator info for given validator address.", + "operationId": "Validator", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.staking.v1beta1.QueryValidatorResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "validator_addr", + "description": "validator_addr defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/validators/{validator_addr}/delegations": { + "get": { + "summary": "ValidatorDelegations queries delegate info for given validator.", + "operationId": "ValidatorDelegations", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.staking.v1beta1.QueryValidatorDelegationsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "validator_addr", + "description": "validator_addr defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}": { + "get": { + "summary": "Delegation queries delegate info for given validator delegator pair.", + "operationId": "Delegation", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.staking.v1beta1.QueryDelegationResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "validator_addr", + "description": "validator_addr defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "delegator_addr", + "description": "delegator_addr defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}/unbonding_delegation": { + "get": { + "summary": "UnbondingDelegation queries unbonding info for given validator delegator pair.", + "operationId": "UnbondingDelegation", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.staking.v1beta1.QueryUnbondingDelegationResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "validator_addr", + "description": "validator_addr defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "delegator_addr", + "description": "delegator_addr defines the delegator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/staking/v1beta1/validators/{validator_addr}/unbonding_delegations": { + "get": { + "summary": "ValidatorUnbondingDelegations queries unbonding delegations of a validator.", + "operationId": "ValidatorUnbondingDelegations", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "validator_addr", + "description": "validator_addr defines the validator address to query for.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "cosmos.base.query.v1beta1.PageRequest": { + "type": "object", + "properties": { + "key": { + "type": "string", + "format": "byte", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." + }, + "offset": { + "type": "string", + "format": "uint64", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." + }, + "limit": { + "type": "string", + "format": "uint64", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." + }, + "count_total": { + "type": "boolean", + "format": "boolean", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." + } + }, + "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", + "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" + }, + "cosmos.base.query.v1beta1.PageResponse": { + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + }, + "cosmos.base.v1beta1.Coin": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + }, + "cosmos.staking.v1beta1.Commission": { + "type": "object", + "properties": { + "commission_rates": { + "$ref": "#/definitions/cosmos.staking.v1beta1.CommissionRates" + }, + "update_time": { + "type": "string", + "format": "date-time" + } + }, + "description": "Commission defines a commission parameters for a given validator." + }, + "cosmos.staking.v1beta1.CommissionRates": { + "type": "object", + "properties": { + "rate": { + "type": "string" + }, + "max_rate": { + "type": "string" + }, + "max_change_rate": { + "type": "string" + } + }, + "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + }, + "cosmos.staking.v1beta1.Delegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "shares": { + "type": "string" + } + }, + "description": "Delegation represents the bond with tokens held by an account. It is\nowned by one delegator, and is associated with the voting power of one\nvalidator." + }, + "cosmos.staking.v1beta1.DelegationResponse": { + "type": "object", + "properties": { + "delegation": { + "$ref": "#/definitions/cosmos.staking.v1beta1.Delegation" + }, + "balance": { + "$ref": "#/definitions/cosmos.base.v1beta1.Coin" + } + }, + "description": "DelegationResponse is equivalent to Delegation except that it contains a balance\nin addition to shares which is more suitable for client responses." + }, + "cosmos.staking.v1beta1.Description": { + "type": "object", + "properties": { + "moniker": { + "type": "string" + }, + "identity": { + "type": "string" + }, + "website": { + "type": "string" + }, + "security_contact": { + "type": "string" + }, + "details": { + "type": "string" + } + }, + "description": "Description defines a validator description." + }, + "cosmos.staking.v1beta1.HistoricalInfo": { + "type": "object", + "properties": { + "header": { + "$ref": "#/definitions/tendermint.types.Header" + }, + "valset": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.staking.v1beta1.Validator" + } + } + }, + "description": "HistoricalInfo contains the historical information that gets stored at\neach height." + }, + "cosmos.staking.v1beta1.Params": { + "type": "object", + "properties": { + "unbonding_time": { + "type": "string" + }, + "max_validators": { + "type": "integer", + "format": "int64" + }, + "max_entries": { + "type": "integer", + "format": "int64" + }, + "historical_entries": { + "type": "integer", + "format": "int64" + }, + "bond_denom": { + "type": "string" + } + }, + "description": "Params defines the parameters for the staking module." + }, + "cosmos.staking.v1beta1.Pool": { + "type": "object", + "properties": { + "not_bonded_tokens": { + "type": "string" + }, + "bonded_tokens": { + "type": "string" + } + }, + "title": "Pool - tracking bonded and not-bonded token supply of the bond denomination" + }, + "cosmos.staking.v1beta1.QueryDelegationResponse": { + "type": "object", + "properties": { + "delegation_response": { + "$ref": "#/definitions/cosmos.staking.v1beta1.DelegationResponse", + "description": "delegation_responses defines the delegation info of a delegation." + } + }, + "description": "QueryDelegationResponse is response type for the Query/Delegation RPC method." + }, + "cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse": { + "type": "object", + "properties": { + "delegation_responses": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.staking.v1beta1.DelegationResponse" + }, + "description": "delegation_responses defines all the delegations' info of a delegator." + }, + "pagination": { + "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryDelegatorDelegationsResponse is response type for the Query/DelegatorDelegations RPC method." + }, + "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse": { + "type": "object", + "properties": { + "unbonding_responses": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.staking.v1beta1.UnbondingDelegation" + } + }, + "pagination": { + "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryUnbondingDelegatorDelegationsResponse is response type for the Query/UnbondingDelegatorDelegations RPC method." + }, + "cosmos.staking.v1beta1.QueryDelegatorValidatorResponse": { + "type": "object", + "properties": { + "validator": { + "$ref": "#/definitions/cosmos.staking.v1beta1.Validator", + "description": "validator defines the the validator info." + } + }, + "description": "QueryDelegatorValidatorResponse response type for the Query/DelegatorValidator RPC method." + }, + "cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse": { + "type": "object", + "properties": { + "validators": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.staking.v1beta1.Validator" + }, + "description": "validators defines the the validators' info of a delegator." + }, + "pagination": { + "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryDelegatorValidatorsResponse is response type for the Query/DelegatorValidators RPC method." + }, + "cosmos.staking.v1beta1.QueryHistoricalInfoResponse": { + "type": "object", + "properties": { + "hist": { + "$ref": "#/definitions/cosmos.staking.v1beta1.HistoricalInfo", + "description": "hist defines the historical info at the given height." + } + }, + "description": "QueryHistoricalInfoResponse is response type for the Query/HistoricalInfo RPC method." + }, + "cosmos.staking.v1beta1.QueryParamsResponse": { + "type": "object", + "properties": { + "params": { + "$ref": "#/definitions/cosmos.staking.v1beta1.Params", + "description": "params holds all the parameters of this module." + } + }, + "description": "QueryParamsResponse is response type for the Query/Params RPC method." + }, + "cosmos.staking.v1beta1.QueryPoolResponse": { + "type": "object", + "properties": { + "pool": { + "$ref": "#/definitions/cosmos.staking.v1beta1.Pool", + "description": "pool defines the pool info." + } + }, + "description": "QueryPoolResponse is response type for the Query/Pool RPC method." + }, + "cosmos.staking.v1beta1.QueryRedelegationsResponse": { + "type": "object", + "properties": { + "redelegation_responses": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.staking.v1beta1.RedelegationResponse" + } + }, + "pagination": { + "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryRedelegationsResponse is response type for the Query/Redelegations RPC method." + }, + "cosmos.staking.v1beta1.QueryUnbondingDelegationResponse": { + "type": "object", + "properties": { + "unbond": { + "$ref": "#/definitions/cosmos.staking.v1beta1.UnbondingDelegation", + "description": "unbond defines the unbonding information of a delegation." + } + }, + "description": "QueryDelegationResponse is response type for the Query/UnbondingDelegation RPC method." + }, + "cosmos.staking.v1beta1.QueryValidatorDelegationsResponse": { + "type": "object", + "properties": { + "delegation_responses": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.staking.v1beta1.DelegationResponse" + } + }, + "pagination": { + "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "title": "QueryValidatorDelegationsResponse is response type for the Query/ValidatorDelegations RPC method" + }, + "cosmos.staking.v1beta1.QueryValidatorResponse": { + "type": "object", + "properties": { + "validator": { + "$ref": "#/definitions/cosmos.staking.v1beta1.Validator", + "description": "validator defines the the validator info." + } + }, + "title": "QueryValidatorResponse is response type for the Query/Validator RPC method" + }, + "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse": { + "type": "object", + "properties": { + "unbonding_responses": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.staking.v1beta1.UnbondingDelegation" + } + }, + "pagination": { + "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryValidatorUnbondingDelegationsResponse is response type for the Query/ValidatorUnbondingDelegations RPC method." + }, + "cosmos.staking.v1beta1.QueryValidatorsResponse": { + "type": "object", + "properties": { + "validators": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.staking.v1beta1.Validator" + }, + "description": "validators contains all the queried validators." + }, + "pagination": { + "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "title": "QueryValidatorsResponse is response type for the Query/Validators RPC method" + }, + "cosmos.staking.v1beta1.Redelegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_src_address": { + "type": "string", + "format": "byte" + }, + "validator_dst_address": { + "type": "string", + "format": "byte" + }, + "entries": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.staking.v1beta1.RedelegationEntry" + } + } + }, + "description": "Redelegation contains the list of a particular delegator's redelegating bonds\nfrom a particular source validator to a particular destination validator." + }, + "cosmos.staking.v1beta1.RedelegationEntry": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "shares_dst": { + "type": "string" + } + }, + "description": "RedelegationEntry defines a redelegation object with relevant metadata." + }, + "cosmos.staking.v1beta1.RedelegationEntryResponse": { + "type": "object", + "properties": { + "redelegation_entry": { + "$ref": "#/definitions/cosmos.staking.v1beta1.RedelegationEntry" + }, + "balance": { + "type": "string" + } + }, + "description": "RedelegationEntryResponse is equivalent to a RedelegationEntry except that it\ncontains a balance in addition to shares which is more suitable for client\nresponses." + }, + "cosmos.staking.v1beta1.RedelegationResponse": { + "type": "object", + "properties": { + "redelegation": { + "$ref": "#/definitions/cosmos.staking.v1beta1.Redelegation" + }, + "entries": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.staking.v1beta1.RedelegationEntryResponse" + } + } + }, + "description": "RedelegationResponse is equivalent to a Redelegation except that its entries\ncontain a balance in addition to shares which is more suitable for client\nresponses." + }, + "cosmos.staking.v1beta1.UnbondingDelegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "entries": { + "type": "array", + "items": { + "$ref": "#/definitions/cosmos.staking.v1beta1.UnbondingDelegationEntry" + } + } + }, + "title": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list" + }, + "cosmos.staking.v1beta1.UnbondingDelegationEntry": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "balance": { + "type": "string" + } + }, + "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." + }, + "cosmos.staking.v1beta1.Validator": { + "type": "object", + "properties": { + "operator_address": { + "type": "string", + "format": "byte" + }, + "consensus_pubkey": { + "type": "string" + }, + "jailed": { + "type": "boolean", + "format": "boolean" + }, + "status": { + "type": "integer", + "format": "int32" + }, + "tokens": { + "type": "string" + }, + "delegator_shares": { + "type": "string" + }, + "description": { + "$ref": "#/definitions/cosmos.staking.v1beta1.Description" + }, + "unbonding_height": { + "type": "string", + "format": "int64" + }, + "unbonding_time": { + "type": "string", + "format": "date-time" + }, + "commission": { + "$ref": "#/definitions/cosmos.staking.v1beta1.Commission" + }, + "min_self_delegation": { + "type": "string" + } + }, + "description": "Validator defines the total amount of bond shares and their exchange rate to\ncoins. Slashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." + }, + "google.protobuf.Any": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + }, + "grpc.gateway.runtime.Error": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/google.protobuf.Any" + } + } + } + }, + "tendermint.types.BlockID": { + "type": "object", + "properties": { + "hash": { + "type": "string", + "format": "byte" + }, + "part_set_header": { + "$ref": "#/definitions/tendermint.types.PartSetHeader" + } + }, + "title": "BlockID" + }, + "tendermint.types.Header": { + "type": "object", + "properties": { + "version": { + "$ref": "#/definitions/tendermint.version.Consensus", + "title": "basic block info" + }, + "chain_id": { + "type": "string" + }, + "height": { + "type": "string", + "format": "int64" + }, + "time": { + "type": "string", + "format": "date-time" + }, + "last_block_id": { + "$ref": "#/definitions/tendermint.types.BlockID", + "title": "prev block info" + }, + "last_commit_hash": { + "type": "string", + "format": "byte", + "title": "hashes of block data" + }, + "data_hash": { + "type": "string", + "format": "byte" + }, + "validators_hash": { + "type": "string", + "format": "byte", + "title": "hashes from the app output from the prev block" + }, + "next_validators_hash": { + "type": "string", + "format": "byte" + }, + "consensus_hash": { + "type": "string", + "format": "byte" + }, + "app_hash": { + "type": "string", + "format": "byte" + }, + "last_results_hash": { + "type": "string", + "format": "byte" + }, + "evidence_hash": { + "type": "string", + "format": "byte", + "title": "consensus info" + }, + "proposer_address": { + "type": "string", + "format": "byte" + } + }, + "description": "Header defines the structure of a Tendermint block header." + }, + "tendermint.types.PartSetHeader": { + "type": "object", + "properties": { + "total": { + "type": "integer", + "format": "int64" + }, + "hash": { + "type": "string", + "format": "byte" + } + }, + "title": "PartsetHeader" + }, + "tendermint.version.Consensus": { + "type": "object", + "properties": { + "block": { + "type": "string", + "format": "uint64" + }, + "app": { + "type": "string", + "format": "uint64" + } + }, + "description": "Consensus captures the consensus rules for processing a block in the blockchain,\nincluding all blockchain data structures and the rules of the application's\nstate transition machine." + } + } +} diff --git a/cosmos/upgrade/v1beta1/query.swagger.json b/cosmos/upgrade/v1beta1/query.swagger.json new file mode 100644 index 000000000000..dc1c49eebb58 --- /dev/null +++ b/cosmos/upgrade/v1beta1/query.swagger.json @@ -0,0 +1,150 @@ +{ + "swagger": "2.0", + "info": { + "title": "cosmos/upgrade/v1beta1/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/cosmos/upgrade/v1beta1/applied_plan/{name}": { + "get": { + "summary": "AppliedPlan queries a previously applied upgrade plan by its name.", + "operationId": "AppliedPlan", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.upgrade.v1beta1.QueryAppliedPlanResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "name", + "description": "name is the name of the applied plan to query for.", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/cosmos/upgrade/v1beta1/current_plan": { + "get": { + "summary": "CurrentPlan queries the current upgrade plan.", + "operationId": "CurrentPlan", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/cosmos.upgrade.v1beta1.QueryCurrentPlanResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "cosmos.upgrade.v1beta1.Plan": { + "type": "object", + "properties": { + "name": { + "type": "string", + "description": "Sets the name for the upgrade. This name will be used by the upgraded version of the software to apply any\nspecial \"on-upgrade\" commands during the first BeginBlock method after the upgrade is applied. It is also used\nto detect whether a software version can handle a given upgrade. If no upgrade handler with this name has been\nset in the software, it will be assumed that the software is out-of-date when the upgrade Time or Height\nis reached and the software will exit." + }, + "time": { + "type": "string", + "format": "date-time", + "description": "The time after which the upgrade must be performed.\nLeave set to its zero value to use a pre-defined Height instead." + }, + "height": { + "type": "string", + "format": "int64", + "description": "The height at which the upgrade must be performed.\nOnly used if Time is not set." + }, + "info": { + "type": "string", + "title": "Any application specific upgrade info to be included on-chain\nsuch as a git commit that validators could automatically upgrade to" + } + }, + "title": "Plan specifies information about a planned upgrade and when it should occur" + }, + "cosmos.upgrade.v1beta1.QueryAppliedPlanResponse": { + "type": "object", + "properties": { + "height": { + "type": "string", + "format": "int64", + "description": "height is the block height at which the plan was applied." + } + }, + "description": "QueryAppliedPlanResponse is the response type for the Query/AppliedPlan RPC method." + }, + "cosmos.upgrade.v1beta1.QueryCurrentPlanResponse": { + "type": "object", + "properties": { + "plan": { + "$ref": "#/definitions/cosmos.upgrade.v1beta1.Plan", + "description": "plan is the current upgrade plan." + } + }, + "description": "QueryCurrentPlanResponse is the response type for the Query/CurrentPlan RPC method." + }, + "google.protobuf.Any": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + }, + "grpc.gateway.runtime.Error": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/google.protobuf.Any" + } + } + } + } + } +} diff --git a/go.mod b/go.mod index 13b736b00549..8be5468104fd 100644 --- a/go.mod +++ b/go.mod @@ -12,7 +12,7 @@ require ( github.com/cosmos/iavl v0.15.0-rc1 github.com/cosmos/ledger-cosmos-go v0.11.1 github.com/enigmampc/btcutil v1.0.3-0.20200723161021-e2fb6adb2a25 - github.com/go-swagger/go-swagger v0.25.0 // indirect + github.com/fsnotify/fsnotify v1.4.9 // indirect github.com/gogo/protobuf v1.3.1 github.com/golang/mock v1.4.4 github.com/golang/protobuf v1.4.2 @@ -20,7 +20,9 @@ require ( github.com/gorilla/mux v1.7.4 github.com/grpc-ecosystem/grpc-gateway v1.14.7 github.com/hashicorp/golang-lru v0.5.4 + github.com/kr/text v0.2.0 // indirect github.com/mattn/go-isatty v0.0.12 + github.com/mitchellh/mapstructure v1.3.2 // indirect github.com/otiai10/copy v1.2.0 github.com/pelletier/go-toml v1.8.0 // indirect github.com/pkg/errors v0.9.1 @@ -28,6 +30,7 @@ require ( github.com/prometheus/common v0.12.0 github.com/rakyll/statik v0.1.7 github.com/regen-network/cosmos-proto v0.3.0 + github.com/spf13/afero v1.3.2 // indirect github.com/spf13/cast v1.3.1 github.com/spf13/cobra v1.0.0 github.com/spf13/jwalterweatherman v1.1.0 // indirect; indirects @@ -39,10 +42,14 @@ require ( github.com/tendermint/go-amino v0.15.1 github.com/tendermint/tendermint v0.34.0-rc3 github.com/tendermint/tm-db v0.6.1 + golang.org/x/net v0.0.0-20200707034311-ab3426394381 // indirect + golang.org/x/text v0.3.3 // indirect google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013 google.golang.org/grpc v1.31.0 google.golang.org/protobuf v1.25.0 + gopkg.in/ini.v1 v1.57.0 // indirect gopkg.in/yaml.v2 v2.3.0 + gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776 // indirect ) replace github.com/gogo/protobuf => github.com/regen-network/protobuf v1.3.2-alpha.regen.4 diff --git a/go.sum b/go.sum index db2c89a1647a..6cf1b12f365d 100644 --- a/go.sum +++ b/go.sum @@ -24,9 +24,6 @@ github.com/DataDog/zstd v1.4.1/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0= github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE= github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= -github.com/PuerkitoBio/purell v1.1.0/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0= -github.com/PuerkitoBio/purell v1.1.1/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0= -github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE= github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo= github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI= github.com/VividCortex/gohistogram v1.0.0 h1:6+hBz+qvs0JOrrNhhmR7lFxo5sINxBCGXrdtl/UvroE= @@ -51,10 +48,6 @@ github.com/armon/go-metrics v0.3.4 h1:Xqf+7f2Vhl9tsqDYmXhnXInUdcrtgpRNpIA15/uldS github.com/armon/go-metrics v0.3.4/go.mod h1:4O98XIr/9W0sxpJ8UaYkvjk10Iff7SnFrb4QAOwNTFc= github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= github.com/aryann/difflib v0.0.0-20170710044230-e206f873d14a/go.mod h1:DAHtR1m6lCRdSC2Tm3DSWRPvIPr6xNKyeHdqDQSQT+A= -github.com/asaskevich/govalidator v0.0.0-20180720115003-f9ffefc3facf/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY= -github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY= -github.com/asaskevich/govalidator v0.0.0-20200108200545-475eaeb16496/go.mod h1:oGkLhpf+kjZl6xBf758TQhh5XrAeiJv/7FRz/2spLIg= -github.com/asaskevich/govalidator v0.0.0-20200428143746-21a406dcc535/go.mod h1:oGkLhpf+kjZl6xBf758TQhh5XrAeiJv/7FRz/2spLIg= github.com/aws/aws-lambda-go v1.13.3/go.mod h1:4UKl9IzQMoD+QF79YdCuzCwp8VbmG4VAQwij/eHl5CU= github.com/aws/aws-sdk-go v1.27.0/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo= github.com/aws/aws-sdk-go-v2 v0.18.0/go.mod h1:JWVYvqSMppoMJC0x5wdwiImzgXTI9FuZwxzkQq9wy+g= @@ -100,7 +93,6 @@ github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkE github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE= github.com/coreos/etcd v3.3.13+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE= github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk= -github.com/coreos/go-oidc v2.2.1+incompatible/go.mod h1:CgnwVTmzoESiwO9qyAFEMiHoZ1nMCKZlZ9V6mm3/LKc= github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= github.com/coreos/go-systemd v0.0.0-20180511133405-39ca1b05acc7/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4= @@ -134,8 +126,6 @@ github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZm github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 h1:tdlZCpZ/P9DhczCTSixgIKmwPv6+wP5DGjqLYw5SUiA= github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no= -github.com/docker/go-units v0.3.3/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= -github.com/docker/go-units v0.4.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo= github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= @@ -165,11 +155,10 @@ github.com/franela/goblin v0.0.0-20200105215937-c9ffbefa60db/go.mod h1:7dvUGVsVB github.com/franela/goreq v0.0.0-20171204163338-bcd34c9993f8/go.mod h1:ZhphrRTfi2rbfLwlschooIH4+wKKDR4Pdxhh+TRoA20= github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I= github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= +github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4= github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= -github.com/globalsign/mgo v0.0.0-20180905125535-1ca0a4f7cbcb/go.mod h1:xkRDCp4j0OGD1HRkm4kmhM+pmpv3AKq5SU7GMg4oO/Q= -github.com/globalsign/mgo v0.0.0-20181015135952-eeefdecb41b8/go.mod h1:xkRDCp4j0OGD1HRkm4kmhM+pmpv3AKq5SU7GMg4oO/Q= github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= @@ -179,92 +168,9 @@ github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= github.com/go-logfmt/logfmt v0.5.0 h1:TrB8swr/68K7m9CcGut2g3UOihhbcbiMAYiuTXdEih4= github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A= -github.com/go-openapi/analysis v0.0.0-20180825180245-b006789cd277/go.mod h1:k70tL6pCuVxPJOHXQ+wIac1FUrvNkHolPie/cLEU6hI= -github.com/go-openapi/analysis v0.17.0/go.mod h1:IowGgpVeD0vNm45So8nr+IcQ3pxVtpRoBWb8PVZO0ik= -github.com/go-openapi/analysis v0.18.0/go.mod h1:IowGgpVeD0vNm45So8nr+IcQ3pxVtpRoBWb8PVZO0ik= -github.com/go-openapi/analysis v0.19.2/go.mod h1:3P1osvZa9jKjb8ed2TPng3f0i/UY9snX6gxi44djMjk= -github.com/go-openapi/analysis v0.19.4/go.mod h1:3P1osvZa9jKjb8ed2TPng3f0i/UY9snX6gxi44djMjk= -github.com/go-openapi/analysis v0.19.5/go.mod h1:hkEAkxagaIvIP7VTn8ygJNkd4kAYON2rCu0v0ObL0AU= -github.com/go-openapi/analysis v0.19.10/go.mod h1:qmhS3VNFxBlquFJ0RGoDtylO9y4pgTAUNE9AEEMdlJQ= -github.com/go-openapi/errors v0.17.0/go.mod h1:LcZQpmvG4wyF5j4IhA73wkLFQg+QJXOQHVjmcZxhka0= -github.com/go-openapi/errors v0.18.0/go.mod h1:LcZQpmvG4wyF5j4IhA73wkLFQg+QJXOQHVjmcZxhka0= -github.com/go-openapi/errors v0.19.2/go.mod h1:qX0BLWsyaKfvhluLejVpVNwNRdXZhEbTA4kxxpKBC94= -github.com/go-openapi/errors v0.19.3/go.mod h1:qX0BLWsyaKfvhluLejVpVNwNRdXZhEbTA4kxxpKBC94= -github.com/go-openapi/errors v0.19.6/go.mod h1:cM//ZKUKyO06HSwqAelJ5NsEMMcpa6VpXe8DOa1Mi1M= -github.com/go-openapi/inflect v0.19.0/go.mod h1:lHpZVlpIQqLyKwJ4N+YSc9hchQy/i12fJykb83CRBH4= -github.com/go-openapi/jsonpointer v0.17.0/go.mod h1:cOnomiV+CVVwFLk0A/MExoFMjwdsUdVpsRhURCKh+3M= -github.com/go-openapi/jsonpointer v0.18.0/go.mod h1:cOnomiV+CVVwFLk0A/MExoFMjwdsUdVpsRhURCKh+3M= -github.com/go-openapi/jsonpointer v0.19.2/go.mod h1:3akKfEdA7DF1sugOqz1dVQHBcuDBPKZGEoHC/NkiQRg= -github.com/go-openapi/jsonpointer v0.19.3/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg= -github.com/go-openapi/jsonreference v0.17.0/go.mod h1:g4xxGn04lDIRh0GJb5QlpE3HfopLOL6uZrK/VgnsK9I= -github.com/go-openapi/jsonreference v0.18.0/go.mod h1:g4xxGn04lDIRh0GJb5QlpE3HfopLOL6uZrK/VgnsK9I= -github.com/go-openapi/jsonreference v0.19.2/go.mod h1:jMjeRr2HHw6nAVajTXJ4eiUwohSTlpa0o73RUL1owJc= -github.com/go-openapi/jsonreference v0.19.3/go.mod h1:rjx6GuL8TTa9VaixXglHmQmIL98+wF9xc8zWvFonSJ8= -github.com/go-openapi/jsonreference v0.19.4/go.mod h1:RdybgQwPxbL4UEjuAruzK1x3nE69AqPYEJeo/TWfEeg= -github.com/go-openapi/loads v0.17.0/go.mod h1:72tmFy5wsWx89uEVddd0RjRWPZm92WRLhf7AC+0+OOU= -github.com/go-openapi/loads v0.18.0/go.mod h1:72tmFy5wsWx89uEVddd0RjRWPZm92WRLhf7AC+0+OOU= -github.com/go-openapi/loads v0.19.0/go.mod h1:72tmFy5wsWx89uEVddd0RjRWPZm92WRLhf7AC+0+OOU= -github.com/go-openapi/loads v0.19.2/go.mod h1:QAskZPMX5V0C2gvfkGZzJlINuP7Hx/4+ix5jWFxsNPs= -github.com/go-openapi/loads v0.19.3/go.mod h1:YVfqhUCdahYwR3f3iiwQLhicVRvLlU/WO5WPaZvcvSI= -github.com/go-openapi/loads v0.19.5/go.mod h1:dswLCAdonkRufe/gSUC3gN8nTSaB9uaS2es0x5/IbjY= -github.com/go-openapi/runtime v0.0.0-20180920151709-4f900dc2ade9/go.mod h1:6v9a6LTXWQCdL8k1AO3cvqx5OtZY/Y9wKTgaoP6YRfA= -github.com/go-openapi/runtime v0.19.0/go.mod h1:OwNfisksmmaZse4+gpV3Ne9AyMOlP1lt4sK4FXt0O64= -github.com/go-openapi/runtime v0.19.4/go.mod h1:X277bwSUBxVlCYR3r7xgZZGKVvBd/29gLDlFGtJ8NL4= -github.com/go-openapi/runtime v0.19.15/go.mod h1:dhGWCTKRXlAfGnQG0ONViOZpjfg0m2gUt9nTQPQZuoo= -github.com/go-openapi/runtime v0.19.20/go.mod h1:Lm9YGCeecBnUUkFTxPC4s1+lwrkJ0pthx8YvyjCfkgk= -github.com/go-openapi/spec v0.17.0/go.mod h1:XkF/MOi14NmjsfZ8VtAKf8pIlbZzyoTvZsdfssdxcBI= -github.com/go-openapi/spec v0.18.0/go.mod h1:XkF/MOi14NmjsfZ8VtAKf8pIlbZzyoTvZsdfssdxcBI= -github.com/go-openapi/spec v0.19.2/go.mod h1:sCxk3jxKgioEJikev4fgkNmwS+3kuYdJtcsZsD5zxMY= -github.com/go-openapi/spec v0.19.3/go.mod h1:FpwSN1ksY1eteniUU7X0N/BgJ7a4WvBFVA8Lj9mJglo= -github.com/go-openapi/spec v0.19.6/go.mod h1:Hm2Jr4jv8G1ciIAo+frC/Ft+rR2kQDh8JHKHb3gWUSk= -github.com/go-openapi/spec v0.19.8/go.mod h1:Hm2Jr4jv8G1ciIAo+frC/Ft+rR2kQDh8JHKHb3gWUSk= -github.com/go-openapi/strfmt v0.17.0/go.mod h1:P82hnJI0CXkErkXi8IKjPbNBM6lV6+5pLP5l494TcyU= -github.com/go-openapi/strfmt v0.18.0/go.mod h1:P82hnJI0CXkErkXi8IKjPbNBM6lV6+5pLP5l494TcyU= -github.com/go-openapi/strfmt v0.19.0/go.mod h1:+uW+93UVvGGq2qGaZxdDeJqSAqBqBdl+ZPMF/cC8nDY= -github.com/go-openapi/strfmt v0.19.2/go.mod h1:0yX7dbo8mKIvc3XSKp7MNfxw4JytCfCD6+bY1AVL9LU= -github.com/go-openapi/strfmt v0.19.3/go.mod h1:0yX7dbo8mKIvc3XSKp7MNfxw4JytCfCD6+bY1AVL9LU= -github.com/go-openapi/strfmt v0.19.4/go.mod h1:eftuHTlB/dI8Uq8JJOyRlieZf+WkkxUuk0dgdHXr2Qk= -github.com/go-openapi/strfmt v0.19.5/go.mod h1:eftuHTlB/dI8Uq8JJOyRlieZf+WkkxUuk0dgdHXr2Qk= -github.com/go-openapi/swag v0.17.0/go.mod h1:AByQ+nYG6gQg71GINrmuDXCPWdL640yX49/kXLo40Tg= -github.com/go-openapi/swag v0.18.0/go.mod h1:AByQ+nYG6gQg71GINrmuDXCPWdL640yX49/kXLo40Tg= -github.com/go-openapi/swag v0.19.2/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk= -github.com/go-openapi/swag v0.19.5/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk= -github.com/go-openapi/swag v0.19.7/go.mod h1:ao+8BpOPyKdpQz3AOJfbeEVpLmWAvlT1IfTe5McPyhY= -github.com/go-openapi/swag v0.19.9/go.mod h1:ao+8BpOPyKdpQz3AOJfbeEVpLmWAvlT1IfTe5McPyhY= -github.com/go-openapi/validate v0.18.0/go.mod h1:Uh4HdOzKt19xGIGm1qHf/ofbX1YQ4Y+MYsct2VUrAJ4= -github.com/go-openapi/validate v0.19.2/go.mod h1:1tRCw7m3jtI8eNWEEliiAqUIcBztB2KDnRCRMUi7GTA= -github.com/go-openapi/validate v0.19.3/go.mod h1:90Vh6jjkTn+OT1Eefm0ZixWNFjhtOH7vS9k0lo6zwJo= -github.com/go-openapi/validate v0.19.10/go.mod h1:RKEZTUWDkxKQxN2jDT7ZnZi2bhZlbNMAuKvKB+IaGx8= github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w= github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk= github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= -github.com/go-swagger/go-swagger v0.25.0 h1:FxhyrWWV8V/A9P6GtI5szWordAdbb6Y0nqdY/y9So2w= -github.com/go-swagger/go-swagger v0.25.0/go.mod h1:9639ioXrPX9E6BbnbaDklGXjNz7upAXoNBwL4Ok11Vk= -github.com/go-swagger/scan-repo-boundary v0.0.0-20180623220736-973b3573c013/go.mod h1:b65mBPzqzZWxOZGxSWrqs4GInLIn+u99Q9q7p+GKni0= -github.com/gobuffalo/attrs v0.0.0-20190224210810-a9411de4debd/go.mod h1:4duuawTqi2wkkpB4ePgWMaai6/Kc6WEz83bhFwpHzj0= -github.com/gobuffalo/depgen v0.0.0-20190329151759-d478694a28d3/go.mod h1:3STtPUQYuzV0gBVOY3vy6CfMm/ljR4pABfrTeHNLHUY= -github.com/gobuffalo/depgen v0.1.0/go.mod h1:+ifsuy7fhi15RWncXQQKjWS9JPkdah5sZvtHc2RXGlg= -github.com/gobuffalo/envy v1.6.15/go.mod h1:n7DRkBerg/aorDM8kbduw5dN3oXGswK5liaSCx4T5NI= -github.com/gobuffalo/envy v1.7.0/go.mod h1:n7DRkBerg/aorDM8kbduw5dN3oXGswK5liaSCx4T5NI= -github.com/gobuffalo/flect v0.1.0/go.mod h1:d2ehjJqGOH/Kjqcoz+F7jHTBbmDb38yXA598Hb50EGs= -github.com/gobuffalo/flect v0.1.1/go.mod h1:8JCgGVbRjJhVgD6399mQr4fx5rRfGKVzFjbj6RE/9UI= -github.com/gobuffalo/flect v0.1.3/go.mod h1:8JCgGVbRjJhVgD6399mQr4fx5rRfGKVzFjbj6RE/9UI= -github.com/gobuffalo/genny v0.0.0-20190329151137-27723ad26ef9/go.mod h1:rWs4Z12d1Zbf19rlsn0nurr75KqhYp52EAGGxTbBhNk= -github.com/gobuffalo/genny v0.0.0-20190403191548-3ca520ef0d9e/go.mod h1:80lIj3kVJWwOrXWWMRzzdhW3DsrdjILVil/SFKBzF28= -github.com/gobuffalo/genny v0.1.0/go.mod h1:XidbUqzak3lHdS//TPu2OgiFB+51Ur5f7CSnXZ/JDvo= -github.com/gobuffalo/genny v0.1.1/go.mod h1:5TExbEyY48pfunL4QSXxlDOmdsD44RRq4mVZ0Ex28Xk= -github.com/gobuffalo/gitgen v0.0.0-20190315122116-cc086187d211/go.mod h1:vEHJk/E9DmhejeLeNt7UVvlSGv3ziL+djtTr3yyzcOw= -github.com/gobuffalo/gogen v0.0.0-20190315121717-8f38393713f5/go.mod h1:V9QVDIxsgKNZs6L2IYiGR8datgMhB577vzTDqypH360= -github.com/gobuffalo/gogen v0.1.0/go.mod h1:8NTelM5qd8RZ15VjQTFkAW6qOMx5wBbW4dSCS3BY8gg= -github.com/gobuffalo/gogen v0.1.1/go.mod h1:y8iBtmHmGc4qa3urIyo1shvOD8JftTtfcKi+71xfDNE= -github.com/gobuffalo/logger v0.0.0-20190315122211-86e12af44bc2/go.mod h1:QdxcLw541hSGtBnhUc4gaNIXRjiDppFGaDqzbrBd3v8= -github.com/gobuffalo/mapi v1.0.1/go.mod h1:4VAGh89y6rVOvm5A8fKFxYG+wIW6LO1FMTG9hnKStFc= -github.com/gobuffalo/mapi v1.0.2/go.mod h1:4VAGh89y6rVOvm5A8fKFxYG+wIW6LO1FMTG9hnKStFc= -github.com/gobuffalo/packd v0.0.0-20190315124812-a385830c7fc0/go.mod h1:M2Juc+hhDXf/PnmBANFCqx4DM3wRbgDvnVWeG2RIxq4= -github.com/gobuffalo/packd v0.1.0/go.mod h1:M2Juc+hhDXf/PnmBANFCqx4DM3wRbgDvnVWeG2RIxq4= -github.com/gobuffalo/packr/v2 v2.0.9/go.mod h1:emmyGweYTm6Kdper+iywB6YK5YzuKchGtJQZ0Odn4pQ= -github.com/gobuffalo/packr/v2 v2.2.0/go.mod h1:CaAwI0GPIAv+5wKLtv8Afwl+Cm78K/I/VCm/3ptBN+0= -github.com/gobuffalo/syncx v0.0.0-20190224160051-33c29581e754/go.mod h1:HhnNqWY95UYwwW3uSASeV7vtgYkT2t16hJgV3AEPUpw= github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2 h1:ZpnhV/YsD2/4cESfV5+Hoeu/iUR3ruzNvZ+yQfO03a0= github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2/go.mod h1:bBOAhwG1umN6/6ZUMtDFBMQR8jRg9O75tm9K00oMsK4= github.com/gogo/googleapis v1.1.0/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s= @@ -276,8 +182,6 @@ github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4er github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= -github.com/golang/mock v1.4.3 h1:GV+pQPG/EUUbkh47niozDcADz6go/dUwhVzdUQHIVRw= -github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= github.com/golang/mock v1.4.4 h1:l75CXGRSwbaYNpl/Z2X1XIIAMSCquvXgpVZDhwEIJsc= github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= @@ -314,7 +218,6 @@ github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OI github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1 h1:EGx4pi6eqNxGaHF6qqu48+N2wcFQ5qg5FXgOdqsJ5d8= @@ -335,8 +238,6 @@ github.com/grpc-ecosystem/go-grpc-middleware v1.0.1-0.20190118093823-f849b5445de github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk= github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY= github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY= -github.com/grpc-ecosystem/grpc-gateway v1.14.6 h1:8ERzHx8aj1Sc47mu9n/AksaKCSWrMchFtkdrS4BIj5o= -github.com/grpc-ecosystem/grpc-gateway v1.14.6/go.mod h1:zdiPV4Yse/1gnckTHtghG4GkDEdKCRJduHpTxT3/jcw= github.com/grpc-ecosystem/grpc-gateway v1.14.7 h1:Nk5kuHrnWUTf/0GL1a/vchH/om9Ap2/HnVna+jYZgTY= github.com/grpc-ecosystem/grpc-gateway v1.14.7/go.mod h1:oYZKL012gGh6LMyg/xA7Q2yq6j8bu0wa+9w14EEthWU= github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c h1:6rhixN/i8ZofjG1Y75iExal34USq5p+wiN1tpie8IrU= @@ -383,11 +284,9 @@ github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NH github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= github.com/influxdata/influxdb1-client v0.0.0-20191209144304-8bf82d3c094d/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo= github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= -github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k= github.com/jmhodges/levigo v1.0.0 h1:q5EC36kV79HWeTBWsod3mG11EgStG3qArTKcvlksN1U= github.com/jmhodges/levigo v1.0.0/go.mod h1:Q6Qx+uH3RAqyK4rFQroq9RL7mdkABMcfhEI+nNuzMJQ= -github.com/joho/godotenv v1.3.0/go.mod h1:7hK45KPybAkOC6peb+G5yklZfMxEjkZhHbwpqxOKXbg= github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo= github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4= github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ= @@ -401,26 +300,21 @@ github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM= -github.com/karrick/godirwalk v1.8.0/go.mod h1:H5KPZjojv4lE+QYImBI8xVtrBRgYrIVsaRPx4tDPEn4= -github.com/karrick/godirwalk v1.10.3/go.mod h1:RoGL9dQei4vP9ilrpETWE8CLOZ1kiN0LhBygSwrAsHA= github.com/keybase/go-keychain v0.0.0-20190712205309-48d3d31d256d h1:Z+RDyXzjKE0i2sTjZ/b1uxiGtPhFy34Ou/Tk0qwN0kM= github.com/keybase/go-keychain v0.0.0-20190712205309-48d3d31d256d/go.mod h1:JJNrCn9otv/2QP4D7SMJBgaleKpOf66PnW6F5WGNRIc= github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4= github.com/kkdai/bstream v1.0.0/go.mod h1:FDnDOHt5Yx4p3FaHcioFT0QjDOtgUpvjeZqAs+NVZZA= -github.com/klauspost/compress v1.9.5/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= -github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= -github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= -github.com/kr/pty v1.1.5/go.mod h1:9r2w37qlBe7rQ6e1fg1S/9xpWHSnaqNdHD3WcMdbPDA= github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/libp2p/go-buffer-pool v0.0.2 h1:QNK2iAFa8gjAe1SPz6mHSMuCcjs+X1wlHzeOSqcmlfs= github.com/libp2p/go-buffer-pool v0.0.2/go.mod h1:MvaB6xw5vOrDl8rYZGLFdKAuk/hRoRZd1Vi32+RXyFM= @@ -430,13 +324,6 @@ github.com/lyft/protoc-gen-validate v0.0.13/go.mod h1:XbGvPuh87YZc5TdIa2/I4pLk0Q github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= github.com/magiconair/properties v1.8.1 h1:ZC2Vc7/ZFkGmsVC9KvOjumD+G5lXy2RtTKyzRKO2BQ4= github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= -github.com/mailru/easyjson v0.0.0-20180823135443-60711f1a8329/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= -github.com/mailru/easyjson v0.0.0-20190312143242-1de009706dbe/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= -github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= -github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= -github.com/mailru/easyjson v0.7.1/go.mod h1:KAzv3t3aY1NaHWoQz1+4F1ccyAH66Jk7yos7ldAVICs= -github.com/markbates/oncer v0.0.0-20181203154359-bf2de49a0be2/go.mod h1:Ld9puTsIW75CHf65OeIOkyKbteujpZVXDpWK6YGZbxE= -github.com/markbates/safe v1.0.1/go.mod h1:nAqgmRi7cY2nqMc92/bSEeQA+R4OheNU2T1kNSCBdG0= github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= @@ -460,12 +347,12 @@ github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0Qu github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE= github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= +github.com/mitchellh/mapstructure v1.3.2 h1:mRS76wmkOn3KkKAyXDu42V+6ebnXWIztFSYGN7GeoRg= github.com/mitchellh/mapstructure v1.3.2/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= -github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc= github.com/mtibben/percent v0.2.1 h1:5gssi8Nqo8QU/r2pynCm+hBQHpkB/uNK7BJCFogWdzs= github.com/mtibben/percent v0.2.1/go.mod h1:KG9uO+SZkUp+VkRHsCdYQV3XSZrrSpR3O9ibNBTZrns= github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= @@ -511,7 +398,6 @@ github.com/pascaldekloe/goe v0.1.0 h1:cBOtyMzM9HTpWjXfbbunk26uA6nG3a8n06Wieeh0Mw github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc= github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k= github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic= -github.com/pelletier/go-toml v1.4.0/go.mod h1:PN7xzY2wHTK0K9p34ErDQMlFxa51Fk0OUruD3k1mMwo= github.com/pelletier/go-toml v1.8.0 h1:Keo9qb7iRJs2voHvunFtuuYFsbWeOBh8/P9v/kVMFtw= github.com/pelletier/go-toml v1.8.0/go.mod h1:D6yutnOGMveHEPV7VQOuvI/gXY61bv+9bAOTRnLElKs= github.com/performancecopilot/speed v3.0.0+incompatible/go.mod h1:/CLtqpZ5gBg1M9iaPbIdPPGyKcA8hKdoy6hAWba7Yac= @@ -528,7 +414,6 @@ github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI= -github.com/pquerna/cachecontrol v0.0.0-20180517163645-1555304b9b35/go.mod h1:prYjPmNq4d1NPVmpShWobRqXY3q7Vp+80DqgxxUrUIA= github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod h1:p2iRAGwDERtqlqzRXnrOVns+ignqQo//hLXqYxZYVNs= github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso= @@ -552,8 +437,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.11.1 h1:0ZISXCMRuCZcxF77aT1BXY5m74mX2vrGYl1dSwBI0Jo= -github.com/prometheus/common v0.11.1/go.mod h1:U+gB1OBLb1lF3O42bTCL+FK18tX9Oar16Clt/msog/s= 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/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= @@ -575,8 +458,6 @@ github.com/regen-network/protobuf v1.3.2-alpha.regen.4 h1:c9jEnU+xm6vqyrQe3M94UF github.com/regen-network/protobuf v1.3.2-alpha.regen.4/go.mod h1:/J8/bR1T/NXyIdQDLUaq15LjNE83nRzkyrLAMcPewig= github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg= github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= -github.com/rogpeppe/go-internal v1.1.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= -github.com/rogpeppe/go-internal v1.2.2/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik= github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= @@ -589,8 +470,6 @@ github.com/sasha-s/go-deadlock v0.2.0/go.mod h1:StQn567HiB1fF2yJ44N9au7wOhrPS3iZ github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc= github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= -github.com/sirupsen/logrus v1.4.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= -github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q= github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88= github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM= @@ -604,8 +483,7 @@ github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasO github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI= github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ= -github.com/spf13/afero v1.2.2 h1:5jhuqJyZCZf2JRofRvN/nIFgIWNzPa3/Vz8mYylgbWc= -github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk= +github.com/spf13/afero v1.3.2 h1:GDarE4TJQI52kYSbSAmLiId1Elfj+xgSDqrUZxFhxlU= github.com/spf13/afero v1.3.2/go.mod h1:5KUK8ByomD5Ti5Artl0RtHeI5pTF7MIDuXL3yY520V4= github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= github.com/spf13/cast v1.3.1 h1:nFm6S0SMdyzrzcmThSipiEubIDy8WEXKNZ0UOgiRpng= @@ -657,20 +535,15 @@ github.com/tendermint/tm-db v0.6.0 h1:Us30k7H1UDcdqoSPhmP8ztAW/SWV6c6OfsfeCiboTC 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/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk= github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= -github.com/toqueteos/webbrowser v1.2.0/go.mod h1:XWoZq4cyp9WeUeak7w7LXRUQf1F1ATJMir8RTqb4ayM= github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM= github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc= github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0= github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA= github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= -github.com/xdg/scram v0.0.0-20180814205039-7eeb5667e42c/go.mod h1:lB8K/P019DLNhemzwFU4jHLhdvlE6uDZjXFejJXr49I= -github.com/xdg/stringprep v0.0.0-20180714160509-73f8eece6fdc/go.mod h1:Jhud4/sHMO4oL310DaZAKk9ZaJ08SJfe+sJh0HrGL1Y= github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU= github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q= -github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/zondax/hid v0.9.0 h1:eiT3P6vNxAEVxXMw66eZUAAnU2zD33JBkfG/EnfAKl8= github.com/zondax/hid v0.9.0/go.mod h1:l5wttcP0jwtdLjqjMMWFVEE7d1zO0jvSPA9OPZxWpEM= go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= @@ -678,11 +551,6 @@ go.etcd.io/bbolt v1.3.3/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= go.etcd.io/bbolt v1.3.5 h1:XAzx9gjCb0Rxj7EoqcClPD1d5ZBxZJk0jbuoPHenBt0= go.etcd.io/bbolt v1.3.5/go.mod h1:G5EMThwa9y8QZGBClrRx5EY+Yw9kAhnjy3bSjsnlVTQ= go.etcd.io/etcd v0.0.0-20191023171146-3cf2f69b5738/go.mod h1:dnLIgRNXwCJa5e+c6mIZCrds/GIG4ncV9HhK5PX7jPg= -go.mongodb.org/mongo-driver v1.0.3/go.mod h1:u7ryQJ+DOzQmeO7zB6MHyr8jkEQvC8vH7qLUO4lqsUM= -go.mongodb.org/mongo-driver v1.1.1/go.mod h1:u7ryQJ+DOzQmeO7zB6MHyr8jkEQvC8vH7qLUO4lqsUM= -go.mongodb.org/mongo-driver v1.3.0/go.mod h1:MSWZXKOynuguX+JSvwP8i+58jYCXxbia8HS3gZBapIE= -go.mongodb.org/mongo-driver v1.3.4/go.mod h1:MSWZXKOynuguX+JSvwP8i+58jYCXxbia8HS3gZBapIE= -go.mongodb.org/mongo-driver v1.3.5/go.mod h1:Ual6Gkco7ZGQw8wE1t4tLnvBsf6yVSM60qW6TgOeJ5c= go.opencensus.io v0.20.1/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk= go.opencensus.io v0.20.2/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk= go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= @@ -701,13 +569,8 @@ golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnf golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20190320223903-b7391e95e576/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20190422162423-af44ce270edf/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE= golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20190530122614-20be4c3c3ed5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20190617133340-57b3e21c3d56/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= @@ -736,11 +599,9 @@ golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCc golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY= golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= -golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20181005035420-146acd28ed58/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -749,7 +610,6 @@ golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73r golang.org/x/net v0.0.0-20190125091013-d26f9f9a57f3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190320064053-1272bf9dcd53/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= @@ -758,14 +618,12 @@ golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20191002035440-2ec189313ef0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200602114024-627f9648deb9/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/net v0.0.0-20200625001655-4c5254603344 h1:vGXIOMxbNfDTk/aXCmfdLgkrSV+Z2tcbze+pEc3v5W4= golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU= golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -775,10 +633,8 @@ golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20190412183630-56d357773e84/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -791,16 +647,11 @@ golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5h golang.org/x/sys v0.0.0-20190130150945-aca44879d564/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190321052220-f7bb7a8bee54/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190419153524-e8e3143a4f4a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190531175056-4c3a928424d2/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190616124812-15dcb6c0061f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190712062909-fae7ac547cb7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -817,11 +668,11 @@ golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1 h1:ogLJMz+qpzav7lGMh10LMvAkM golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae h1:Ih9Yo4hSPImZOpfGuA4bR/ORKTAbhZo2AbWNRCnevdo= golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= +golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= @@ -836,16 +687,10 @@ golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3 golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20190329151228-23e29df326fe/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20190416151739-9c9e1878f421/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20190420181800-aa740d480789/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= -golang.org/x/tools v0.0.0-20190531172133-b3315ee88b7d/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= -golang.org/x/tools v0.0.0-20190614205625-5aca471b1d59/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= -golang.org/x/tools v0.0.0-20190617190820-da514acc4774/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= @@ -854,10 +699,8 @@ golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtn golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191112195655-aa38f8e97acc/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200110213125-a7a6caa82ab2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200717024301-6ddee64345a6/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= @@ -873,7 +716,6 @@ google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= -google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20180831171423-11092d34479b/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= @@ -902,7 +744,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.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= 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= @@ -930,9 +771,9 @@ gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMy gopkg.in/gcfg.v1 v1.2.3/go.mod h1:yesOnuUOFQAhST5vPY4nbZsb/huCgGGXlipJsBn0b3o= gopkg.in/ini.v1 v1.51.0 h1:AQvPpx3LzTDM0AjnIRlVFwFFGC+npRopjZxLJj6gdno= gopkg.in/ini.v1 v1.51.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= +gopkg.in/ini.v1 v1.57.0 h1:9unxIsFcTt4I55uWluz+UmL95q4kdJ0buvQ1ZIqVQww= gopkg.in/ini.v1 v1.57.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo= -gopkg.in/square/go-jose.v2 v2.5.1/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76mk0e1AI= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI= @@ -942,12 +783,11 @@ gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU= gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.0-20200605160147-a5ece683394c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776 h1:tQIYjPdBoyREyB9XMu+nnTclpTYkz2zFM+lzLJFO4gQ= gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= @@ -956,7 +796,5 @@ honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWh 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/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= -rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= -rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o= sourcegraph.com/sourcegraph/appdash v0.0.0-20190731080439-ebfcffb1b5c0/go.mod h1:hI742Nqp5OhwiqlzhgfbWU4mW4yO10fP+LoT9WOswdU= diff --git a/ibc/channel/query.swagger.json b/ibc/channel/query.swagger.json new file mode 100644 index 000000000000..3dd6b7074f87 --- /dev/null +++ b/ibc/channel/query.swagger.json @@ -0,0 +1,982 @@ +{ + "swagger": "2.0", + "info": { + "title": "ibc/channel/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/ibc/channel/v1beta1/channels": { + "get": { + "summary": "Channels queries all the IBC channels of a chain.", + "operationId": "Channels", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/ibc.channel.QueryChannelsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}": { + "get": { + "summary": "Channel queries an IBC Channel.", + "operationId": "Channel", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/ibc.channel.QueryChannelResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/client_state": { + "get": { + "summary": "ChannelClientState queries for the client state for the channel associated\nwith the provided channel identifiers.", + "operationId": "ChannelClientState", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/ibc.channel.QueryChannelClientStateResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/consensus_state/{height}": { + "get": { + "summary": "ChannelConsensusState queries for the consensus state for the channel\nassociated with the provided channel identifiers.", + "operationId": "ChannelConsensusState", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/ibc.channel.QueryChannelConsensusStateResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "height", + "description": "height of the consensus state", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/next_sequence": { + "get": { + "summary": "NextSequenceReceive returns the next receive sequence for a given channel.", + "operationId": "NextSequenceReceive", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/ibc.channel.QueryNextSequenceReceiveResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_acks/{sequence}": { + "get": { + "summary": "PacketAcknowledgement queries a stored packet acknowledgement hash.", + "operationId": "PacketAcknowledgement", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/ibc.channel.QueryPacketAcknowledgementResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "sequence", + "description": "packet sequence", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments": { + "get": { + "summary": "PacketCommitments returns the all the packet commitments hashes associated\nwith a channel.", + "operationId": "PacketCommitments", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/ibc.channel.QueryPacketCommitmentsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_commitment_sequences}/packet_acks/{acknowledgements}/unrelayed_packets": { + "get": { + "summary": "UnrelayedPackets returns all the unrelayed IBC packets associated with a\nchannel and sequences.", + "operationId": "UnrelayedPackets", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/ibc.channel.QueryUnrelayedPacketsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "packet_commitment_sequences", + "description": "list of packet sequences", + "in": "path", + "required": true, + "type": "array", + "items": { + "type": "string", + "format": "uint64" + }, + "collectionFormat": "csv", + "minItems": 1 + }, + { + "name": "acknowledgements", + "description": "flag indicating if the return value is packet commitments or\nacknowledgements", + "in": "path", + "required": true, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/{sequence}": { + "get": { + "summary": "PacketCommitment queries a stored packet commitment hash.", + "operationId": "PacketCommitment", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/ibc.channel.QueryPacketCommitmentResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "sequence", + "description": "packet sequence", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/connections/{connection}/channels": { + "get": { + "summary": "ConnectionChannels queries all the channels associated with a connection\nend.", + "operationId": "ConnectionChannels", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/ibc.channel.QueryConnectionChannelsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "connection", + "description": "connection unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "cosmos.base.query.v1beta1.PageRequest": { + "type": "object", + "properties": { + "key": { + "type": "string", + "format": "byte", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." + }, + "offset": { + "type": "string", + "format": "uint64", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." + }, + "limit": { + "type": "string", + "format": "uint64", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." + }, + "count_total": { + "type": "boolean", + "format": "boolean", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." + } + }, + "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", + "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" + }, + "cosmos.base.query.v1beta1.PageResponse": { + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + }, + "google.protobuf.Any": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := \u0026pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "grpc.gateway.runtime.Error": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/google.protobuf.Any" + } + } + } + }, + "ibc.channel.Channel": { + "type": "object", + "properties": { + "state": { + "$ref": "#/definitions/ibc.channel.State", + "title": "current state of the channel end" + }, + "ordering": { + "$ref": "#/definitions/ibc.channel.Order", + "title": "whether the channel is ordered or unordered" + }, + "counterparty": { + "$ref": "#/definitions/ibc.channel.Counterparty", + "title": "counterparty channel end" + }, + "connection_hops": { + "type": "array", + "items": { + "type": "string" + }, + "title": "list of connection identifiers, in order, along which packets sent on this\nchannel will travel" + }, + "version": { + "type": "string", + "title": "opaque channel version, which is agreed upon during the handshake" + } + }, + "description": "Channel defines pipeline for exactly-once packet delivery between specific\nmodules on separate blockchains, which has at least one end capable of sending\npackets and one end capable of receiving packets." + }, + "ibc.channel.Counterparty": { + "type": "object", + "properties": { + "port_id": { + "type": "string", + "description": "port on the counterparty chain which owns the other end of the channel." + }, + "channel_id": { + "type": "string", + "title": "channel end on the counterparty chain" + } + }, + "title": "Counterparty defines a channel end counterparty" + }, + "ibc.channel.IdentifiedChannel": { + "type": "object", + "properties": { + "state": { + "$ref": "#/definitions/ibc.channel.State", + "title": "current state of the channel end" + }, + "ordering": { + "$ref": "#/definitions/ibc.channel.Order", + "title": "whether the channel is ordered or unordered" + }, + "counterparty": { + "$ref": "#/definitions/ibc.channel.Counterparty", + "title": "counterparty channel end" + }, + "connection_hops": { + "type": "array", + "items": { + "type": "string" + }, + "title": "list of connection identifiers, in order, along which packets sent on this\nchannel will travel" + }, + "version": { + "type": "string", + "title": "opaque channel version, which is agreed upon during the handshake" + }, + "port_id": { + "type": "string", + "title": "port identifier" + }, + "channel_id": { + "type": "string", + "title": "channel identifier" + } + }, + "description": "IdentifiedChannel defines a channel with additional port and channel identifier\nfields." + }, + "ibc.channel.Order": { + "type": "string", + "enum": [ + "ORDER_NONE_UNSPECIFIED", + "ORDER_UNORDERED", + "ORDER_ORDERED" + ], + "default": "ORDER_NONE_UNSPECIFIED", + "description": "- ORDER_NONE_UNSPECIFIED: zero-value for channel ordering\n - ORDER_UNORDERED: packets can be delivered in any order, which may differ from the order in which they were sent.\n - ORDER_ORDERED: packets are delivered exactly in the order which they were sent", + "title": "Order defines if a channel is ORDERED or UNORDERED" + }, + "ibc.channel.PacketAckCommitment": { + "type": "object", + "properties": { + "port_id": { + "type": "string", + "description": "channel port identifier." + }, + "channel_id": { + "type": "string", + "description": "channel unique identifier." + }, + "sequence": { + "type": "string", + "format": "uint64", + "description": "packet sequence." + }, + "hash": { + "type": "string", + "format": "byte", + "description": "packet commitment hash." + } + }, + "description": "PacketAckCommitment defines the genesis type necessary to retrieve and store\nacknowlegements." + }, + "ibc.channel.QueryChannelClientStateResponse": { + "type": "object", + "properties": { + "identified_client_state": { + "$ref": "#/definitions/ibc.client.IdentifiedClientState", + "title": "client state associated with the channel" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryChannelClientStateResponse is the Response type for the\nQuery/QueryChannelClientState RPC method" + }, + "ibc.channel.QueryChannelConsensusStateResponse": { + "type": "object", + "properties": { + "consensus_state": { + "$ref": "#/definitions/google.protobuf.Any", + "title": "consensus state associated with the channel" + }, + "client_id": { + "type": "string", + "title": "client ID associated with the consensus state" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryChannelClientStateResponse is the Response type for the\nQuery/QueryChannelClientState RPC method" + }, + "ibc.channel.QueryChannelResponse": { + "type": "object", + "properties": { + "channel": { + "$ref": "#/definitions/ibc.channel.Channel", + "title": "channel associated with the request identifiers" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "description": "QueryChannelResponse is the response type for the Query/Channel RPC method.\nBesides the Channel end, it includes a proof and the height from which the\nproof was retrieved." + }, + "ibc.channel.QueryChannelsResponse": { + "type": "object", + "properties": { + "channels": { + "type": "array", + "items": { + "$ref": "#/definitions/ibc.channel.IdentifiedChannel" + }, + "description": "list of stored channels of the chain." + }, + "pagination": { + "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", + "title": "pagination response" + }, + "height": { + "type": "string", + "format": "int64", + "title": "query block height" + } + }, + "description": "QueryChannelsResponse is the response type for the Query/Channels RPC method." + }, + "ibc.channel.QueryConnectionChannelsResponse": { + "type": "object", + "properties": { + "channels": { + "type": "array", + "items": { + "$ref": "#/definitions/ibc.channel.IdentifiedChannel" + }, + "description": "list of channels associated with a connection." + }, + "pagination": { + "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", + "title": "pagination response" + }, + "height": { + "type": "string", + "format": "int64", + "title": "query block height" + } + }, + "title": "QueryConnectionChannelsResponse is the Response type for the\nQuery/QueryConnectionChannels RPC method" + }, + "ibc.channel.QueryNextSequenceReceiveResponse": { + "type": "object", + "properties": { + "next_sequence_receive": { + "type": "string", + "format": "uint64", + "title": "next sequence receive number" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QuerySequenceResponse is the request type for the\nQuery/QueryNextSequenceReceiveResponse RPC method" + }, + "ibc.channel.QueryPacketAcknowledgementResponse": { + "type": "object", + "properties": { + "acknowledgement": { + "type": "string", + "format": "byte", + "title": "packet associated with the request fields" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryPacketAcknowledgementResponse defines the client query response for a\npacket which also includes a proof, its path and the height form which the\nproof was retrieved" + }, + "ibc.channel.QueryPacketCommitmentResponse": { + "type": "object", + "properties": { + "commitment": { + "type": "string", + "format": "byte", + "title": "packet associated with the request fields" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryPacketCommitmentResponse defines the client query response for a packet\nwhich also includes a proof, its path and the height form which the proof was\nretrieved" + }, + "ibc.channel.QueryPacketCommitmentsResponse": { + "type": "object", + "properties": { + "commitments": { + "type": "array", + "items": { + "$ref": "#/definitions/ibc.channel.PacketAckCommitment" + } + }, + "pagination": { + "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", + "title": "pagination response" + }, + "height": { + "type": "string", + "format": "int64", + "title": "query block height" + } + }, + "title": "QueryPacketCommitmentsResponse is the request type for the\nQuery/QueryPacketCommitments RPC method" + }, + "ibc.channel.QueryUnrelayedPacketsResponse": { + "type": "object", + "properties": { + "sequences": { + "type": "array", + "items": { + "type": "string", + "format": "uint64" + }, + "title": "list of unrelayed packet sequences" + }, + "height": { + "type": "string", + "format": "int64", + "title": "query block height" + } + }, + "title": "QueryUnrelayedPacketsResponse is the request type for the\nQuery/UnrelayedPacketCommitments RPC method" + }, + "ibc.channel.State": { + "type": "string", + "enum": [ + "STATE_UNINITIALIZED_UNSPECIFIED", + "STATE_INIT", + "STATE_TRYOPEN", + "STATE_OPEN", + "STATE_CLOSED" + ], + "default": "STATE_UNINITIALIZED_UNSPECIFIED", + "description": "State defines if a channel is in one of the following states:\nCLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.\n\n - STATE_UNINITIALIZED_UNSPECIFIED: Default State\n - STATE_INIT: A channel has just started the opening handshake.\n - STATE_TRYOPEN: A channel has acknowledged the handshake step on the counterparty chain.\n - STATE_OPEN: A channel has completed the handshake. Open channels are\nready to send and receive packets.\n - STATE_CLOSED: A channel has been closed and can no longer be used to send or receive packets." + }, + "ibc.client.IdentifiedClientState": { + "type": "object", + "properties": { + "id": { + "type": "string", + "title": "client identifier" + }, + "client_state": { + "$ref": "#/definitions/google.protobuf.Any" + } + }, + "description": "IdentifiedClientState defines a client state with additional client identifier field." + } + } +} diff --git a/ibc/connection/query.swagger.json b/ibc/connection/query.swagger.json new file mode 100644 index 000000000000..5c648c1d9deb --- /dev/null +++ b/ibc/connection/query.swagger.json @@ -0,0 +1,520 @@ +{ + "swagger": "2.0", + "info": { + "title": "ibc/connection/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/ibc/connection/v1beta1/client_connections/{client_id}": { + "get": { + "summary": "ClientConnections queries the connection paths associated with a client\nstate.", + "operationId": "ClientConnections", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/ibc.connection.QueryClientConnectionsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "client_id", + "description": "client identifier associated with a connection", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/connection/v1beta1/connections": { + "get": { + "summary": "Connections queries all the IBC connections of a chain.", + "operationId": "Connections", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/ibc.connection.QueryConnectionsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/connection/v1beta1/connections/{connection_id}": { + "get": { + "summary": "Connection queries an IBC connection end.", + "operationId": "Connection", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/ibc.connection.QueryConnectionResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "connection_id", + "description": "connection unique identifier", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/connection/v1beta1/connections/{connection_id}/client_state": { + "get": { + "summary": "ConnectionClientState queries the client state associated with the\nconnection.", + "operationId": "ConnectionClientState", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/ibc.connection.QueryConnectionClientStateResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "connection_id", + "description": "connection identifier", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/connection/v1beta1/connections/{connection_id}/consensus_state": { + "get": { + "summary": "ConnectionConsensusState queries the consensus state associated with the\nconnection.", + "operationId": "ConnectionConsensusState", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/ibc.connection.QueryConnectionConsensusStateResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "connection_id", + "description": "connection identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "height", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + } + ], + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "cosmos.base.query.v1beta1.PageRequest": { + "type": "object", + "properties": { + "key": { + "type": "string", + "format": "byte", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." + }, + "offset": { + "type": "string", + "format": "uint64", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." + }, + "limit": { + "type": "string", + "format": "uint64", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." + }, + "count_total": { + "type": "boolean", + "format": "boolean", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." + } + }, + "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", + "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" + }, + "cosmos.base.query.v1beta1.PageResponse": { + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + }, + "google.protobuf.Any": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := \u0026pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "grpc.gateway.runtime.Error": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/google.protobuf.Any" + } + } + } + }, + "ibc.client.IdentifiedClientState": { + "type": "object", + "properties": { + "id": { + "type": "string", + "title": "client identifier" + }, + "client_state": { + "$ref": "#/definitions/google.protobuf.Any" + } + }, + "description": "IdentifiedClientState defines a client state with additional client identifier field." + }, + "ibc.commitment.MerklePrefix": { + "type": "object", + "properties": { + "key_prefix": { + "type": "string", + "format": "byte" + } + }, + "title": "MerklePrefix is merkle path prefixed to the key.\nThe constructed key from the Path and the key will be append(Path.KeyPath, append(Path.KeyPrefix, key...))" + }, + "ibc.connection.ConnectionEnd": { + "type": "object", + "properties": { + "client_id": { + "type": "string", + "description": "client associated with this connection." + }, + "versions": { + "type": "array", + "items": { + "type": "string" + }, + "title": "IBC version which can be utilised to determine encodings or protocols for\nchannels or packets utilising this connection" + }, + "state": { + "$ref": "#/definitions/ibc.connection.State", + "description": "current state of the connection end." + }, + "counterparty": { + "$ref": "#/definitions/ibc.connection.Counterparty", + "description": "counterparty chain associated with this connection." + } + }, + "description": "ConnectionEnd defines a stateful object on a chain connected to another\nseparate one. NOTE: there must only be 2 defined ConnectionEnds to establish\na connection between two chains." + }, + "ibc.connection.Counterparty": { + "type": "object", + "properties": { + "client_id": { + "type": "string", + "description": "identifies the client on the counterparty chain associated with a given\nconnection." + }, + "connection_id": { + "type": "string", + "description": "identifies the connection end on the counterparty chain associated with a\ngiven connection." + }, + "prefix": { + "$ref": "#/definitions/ibc.commitment.MerklePrefix", + "title": "commitment merkle prefix of the counterparty chain" + } + }, + "description": "Counterparty defines the counterparty chain associated with a connection end." + }, + "ibc.connection.IdentifiedConnection": { + "type": "object", + "properties": { + "id": { + "type": "string", + "description": "connection identifier." + }, + "client_id": { + "type": "string", + "description": "client associated with this connection." + }, + "versions": { + "type": "array", + "items": { + "type": "string" + }, + "title": "IBC version which can be utilised to determine encodings or protocols for\nchannels or packets utilising this connection" + }, + "state": { + "$ref": "#/definitions/ibc.connection.State", + "description": "current state of the connection end." + }, + "counterparty": { + "$ref": "#/definitions/ibc.connection.Counterparty", + "description": "counterparty chain associated with this connection." + } + }, + "description": "IdentifiedConnection defines a connection with additional connection\nidentifier field." + }, + "ibc.connection.QueryClientConnectionsResponse": { + "type": "object", + "properties": { + "connection_paths": { + "type": "array", + "items": { + "type": "string" + }, + "description": "slice of all the connection paths associated with a client." + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was generated" + } + }, + "title": "QueryClientConnectionsResponse is the response type for the\nQuery/ClientConnections RPC method" + }, + "ibc.connection.QueryConnectionClientStateResponse": { + "type": "object", + "properties": { + "identified_client_state": { + "$ref": "#/definitions/ibc.client.IdentifiedClientState", + "title": "client state associated with the channel" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryConnectionClientStateResponse is the response type for the\nQuery/ConnectionClientState RPC method" + }, + "ibc.connection.QueryConnectionConsensusStateResponse": { + "type": "object", + "properties": { + "consensus_state": { + "$ref": "#/definitions/google.protobuf.Any", + "title": "consensus state associated with the channel" + }, + "client_id": { + "type": "string", + "title": "client ID associated with the consensus state" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryConnectionConsensusStateResponse is the response type for the\nQuery/ConnectionConsensusState RPC method" + }, + "ibc.connection.QueryConnectionResponse": { + "type": "object", + "properties": { + "connection": { + "$ref": "#/definitions/ibc.connection.ConnectionEnd", + "title": "connection associated with the request identifier" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "description": "QueryConnectionResponse is the response type for the Query/Connection RPC\nmethod. Besides the connection end, it includes a proof and the height from\nwhich the proof was retrieved." + }, + "ibc.connection.QueryConnectionsResponse": { + "type": "object", + "properties": { + "connections": { + "type": "array", + "items": { + "$ref": "#/definitions/ibc.connection.IdentifiedConnection" + }, + "description": "list of stored connections of the chain." + }, + "pagination": { + "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", + "title": "pagination response" + }, + "height": { + "type": "string", + "format": "int64", + "title": "query block height" + } + }, + "description": "QueryConnectionsResponse is the response type for the Query/Connections RPC\nmethod." + }, + "ibc.connection.State": { + "type": "string", + "enum": [ + "STATE_UNINITIALIZED_UNSPECIFIED", + "STATE_INIT", + "STATE_TRYOPEN", + "STATE_OPEN" + ], + "default": "STATE_UNINITIALIZED_UNSPECIFIED", + "description": "State defines if a connection is in one of the following states:\nINIT, TRYOPEN, OPEN or UNINITIALIZED.\n\n - STATE_UNINITIALIZED_UNSPECIFIED: Default State\n - STATE_INIT: A connection end has just started the opening handshake.\n - STATE_TRYOPEN: A connection end has acknowledged the handshake step on the counterparty\nchain.\n - STATE_OPEN: A connection end has completed the handshake." + } + } +} diff --git a/ibc/transfer/query.swagger.json b/ibc/transfer/query.swagger.json new file mode 100644 index 000000000000..2e04eea37fdb --- /dev/null +++ b/ibc/transfer/query.swagger.json @@ -0,0 +1,273 @@ +{ + "swagger": "2.0", + "info": { + "title": "ibc/transfer/query.proto", + "version": "version not set" + }, + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "paths": { + "/ibc_transfer/v1beta1/denom_traces": { + "get": { + "summary": "DenomTraces queries all denomination traces.", + "operationId": "DenomTraces", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/ibc.transfer.QueryDenomTracesResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc_transfer/v1beta1/denom_traces/{hash}": { + "get": { + "summary": "DenomTrace queries a denomination trace information.", + "operationId": "DenomTrace", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/ibc.transfer.QueryDenomTraceResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "parameters": [ + { + "name": "hash", + "description": "hash (in hex format) of the denomination trace information.", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc_transfer/v1beta1/params": { + "get": { + "summary": "Params queries all parameters of the ibc-transfer module.", + "operationId": "Params", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/ibc.transfer.QueryParamsResponse" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "$ref": "#/definitions/grpc.gateway.runtime.Error" + } + } + }, + "tags": [ + "Query" + ] + } + } + }, + "definitions": { + "cosmos.base.query.v1beta1.PageRequest": { + "type": "object", + "properties": { + "key": { + "type": "string", + "format": "byte", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." + }, + "offset": { + "type": "string", + "format": "uint64", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." + }, + "limit": { + "type": "string", + "format": "uint64", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." + }, + "count_total": { + "type": "boolean", + "format": "boolean", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." + } + }, + "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", + "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" + }, + "cosmos.base.query.v1beta1.PageResponse": { + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", + "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + }, + "google.protobuf.Any": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + }, + "grpc.gateway.runtime.Error": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/definitions/google.protobuf.Any" + } + } + } + }, + "ibc.transfer.DenomTrace": { + "type": "object", + "properties": { + "path": { + "type": "string", + "description": "path defines the chain of port/channel identifiers used for tracing the source of the fungible\ntoken." + }, + "base_denom": { + "type": "string", + "description": "base denomination of the relayed fungible token." + } + }, + "description": "DenomTrace contains the base denomination for ICS20 fungible tokens and the source tracing\ninformation path." + }, + "ibc.transfer.Params": { + "type": "object", + "properties": { + "send_enabled": { + "type": "boolean", + "format": "boolean", + "description": "send_enabled enables or disables all cross-chain token transfers from this chain." + }, + "receive_enabled": { + "type": "boolean", + "format": "boolean", + "description": "receive_enabled enables or disables all cross-chain token transfers to this chain." + } + }, + "description": "Params defines the set of IBC transfer parameters.\nNOTE: To prevent a single token from being transferred, set the TransfersEnabled parameter to\ntrue and then set the bank module's SendEnabled parameter for the denomination to false." + }, + "ibc.transfer.QueryDenomTraceResponse": { + "type": "object", + "properties": { + "denom_trace": { + "$ref": "#/definitions/ibc.transfer.DenomTrace", + "description": "denom_trace returns the requested denomination trace information." + } + }, + "description": "QueryDenomTraceResponse is the response type for the Query/DenomTrace RPC method." + }, + "ibc.transfer.QueryDenomTracesResponse": { + "type": "object", + "properties": { + "denom_traces": { + "type": "array", + "items": { + "$ref": "#/definitions/ibc.transfer.DenomTrace" + }, + "description": "denom_traces returns all denominations trace information." + }, + "pagination": { + "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", + "description": "pagination defines the pagination in the response." + } + }, + "description": "QueryConnectionsResponse is the response type for the Query/DenomTraces RPC method." + }, + "ibc.transfer.QueryParamsResponse": { + "type": "object", + "properties": { + "params": { + "$ref": "#/definitions/ibc.transfer.Params", + "description": "params defines the parameters of the module." + } + }, + "description": "QueryParamsResponse is the response type for the Query/Params RPC method." + } + } +} diff --git a/scripts/go-swagger.sh b/scripts/go-swagger.sh index ff6aa59ed016..f844e295c0fb 100644 --- a/scripts/go-swagger.sh +++ b/scripts/go-swagger.sh @@ -1,4 +1,4 @@ -download_url=$(curl -s https://api.github.com/repos/go-swagger/go-swagger/releases/latest | \ - jq -r '.assets[] | select(.name | contains("'"$(uname | tr '[:upper:]' '[:lower:]')"'_amd64")) | .browser_download_url') -curl -o /usr/local/bin/swagger -L'#' "$download_url" -chmod +x /usr/local/bin/swagger \ No newline at end of file +dir=$(mktemp -d) +git clone https://github.com/go-swagger/go-swagger "$dir" +cd "$dir" +go install ./cmd/swagger \ No newline at end of file diff --git a/scripts/protocgen.sh b/scripts/protocgen.sh index 08472ff11000..f65e4ce1db4e 100755 --- a/scripts/protocgen.sh +++ b/scripts/protocgen.sh @@ -24,25 +24,16 @@ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. \ query_file=$(find "${dir}" -maxdepth 1 -name 'query.proto') if [[ ! -z "$query_file" ]]; then query_files=${query_files}" ${query_file}" -# protoc \ -# -I "proto" \ -# -I "third_party/proto" \ -# "$query_file" \ -# --go_out=plugins=grpc:pkg \ -# --swagger_out=logtostderr=true,fqn_for_swagger_name=true:. + protoc \ + -I "proto" \ + -I "third_party/proto" \ + "$query_file" \ + --swagger_out=logtostderr=true,stderrthreshold=1000,fqn_for_swagger_name=true,simple_operation_ids=true:. fi - - proto_files=${proto_files}" ${dir:2}/*.proto" done -protoc \ - -I "proto" \ - -I "third_party/proto" \ - --swagger_out=logtostderr=true,fqn_for_swagger_name=true:. \ - --go_out=plugins=grpc:pkg $(find ./ -name 'query.proto') - #echo $query_files #protoc \ #-I "proto" \ @@ -58,4 +49,4 @@ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. ./testutil cp -r github.com/cosmos/cosmos-sdk/* ./ rm -rf github.com -#swagger mixin ./x/auth/**/query.swagger.json ./x/**/**/*swagger.json \ No newline at end of file +swagger-combine ./client/grpc-gateway/config.json -o ./client/grpc-gateway/swagger.json --continueOnConflictingPaths true --includeDefinitions true --continueOnError true From 7babaccd73fc72494342628278fd55a14b9dcf68 Mon Sep 17 00:00:00 2001 From: anilCSE Date: Sat, 22 Aug 2020 16:54:06 +0530 Subject: [PATCH 10/27] Fix description --- client/grpc-gateway/config.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/client/grpc-gateway/config.json b/client/grpc-gateway/config.json index 428c0379d0b5..038bb288afc2 100644 --- a/client/grpc-gateway/config.json +++ b/client/grpc-gateway/config.json @@ -1,7 +1,7 @@ { "swagger": "2.0", "info": { - "title": "Basic Swagger Combine Example", + "title": "Cosmos SDK - GRPC Gateway", "version": "1.0.0" }, "apis": [ From 73a3078b9964db58f80e0ed556b7d501f1dba8c9 Mon Sep 17 00:00:00 2001 From: anilCSE Date: Sat, 22 Aug 2020 16:55:43 +0530 Subject: [PATCH 11/27] remove unnecessary config option --- client/grpc-gateway/swagger.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/client/grpc-gateway/swagger.json b/client/grpc-gateway/swagger.json index 2a17336257d1..26000f77ae55 100644 --- a/client/grpc-gateway/swagger.json +++ b/client/grpc-gateway/swagger.json @@ -1,7 +1,7 @@ { "swagger": "2.0", "info": { - "title": "Basic Swagger Combine Example", + "title": "Cosmos SDK - GRPC Gateway", "version": "1.0.0" }, "paths": { From 148bce9fd3a99af117eff46c4a3243efdb1a6842 Mon Sep 17 00:00:00 2001 From: anilCSE Date: Sat, 22 Aug 2020 16:57:28 +0530 Subject: [PATCH 12/27] remove go-swagger dependency --- contrib/devtools/Makefile | 6 +----- scripts/go-swagger.sh | 4 ---- scripts/protocgen.sh | 2 +- 3 files changed, 2 insertions(+), 10 deletions(-) delete mode 100644 scripts/go-swagger.sh diff --git a/contrib/devtools/Makefile b/contrib/devtools/Makefile index a54f84bcda7b..3557f345b75a 100644 --- a/contrib/devtools/Makefile +++ b/contrib/devtools/Makefile @@ -85,7 +85,7 @@ ifeq ($(UNAME_S),Darwin) PROTOC_ZIP ?= protoc-3.11.2-osx-x86_64.zip endif -proto-tools: proto-tools-stamp go-swagger buf +proto-tools: proto-tools-stamp buf proto-tools-stamp: @echo "Installing protoc compiler..." @@ -103,10 +103,6 @@ proto-tools-stamp: touch $@ -go-swagger: - @echo "Installing go-swagger..." - @./scripts/go-swagger.sh - buf: buf-stamp buf-stamp: diff --git a/scripts/go-swagger.sh b/scripts/go-swagger.sh deleted file mode 100644 index f844e295c0fb..000000000000 --- a/scripts/go-swagger.sh +++ /dev/null @@ -1,4 +0,0 @@ -dir=$(mktemp -d) -git clone https://github.com/go-swagger/go-swagger "$dir" -cd "$dir" -go install ./cmd/swagger \ No newline at end of file diff --git a/scripts/protocgen.sh b/scripts/protocgen.sh index f65e4ce1db4e..dddbe7deab6c 100755 --- a/scripts/protocgen.sh +++ b/scripts/protocgen.sh @@ -49,4 +49,4 @@ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. ./testutil cp -r github.com/cosmos/cosmos-sdk/* ./ rm -rf github.com -swagger-combine ./client/grpc-gateway/config.json -o ./client/grpc-gateway/swagger.json --continueOnConflictingPaths true --includeDefinitions true --continueOnError true +swagger-combine ./client/grpc-gateway/config.json -o ./client/grpc-gateway/swagger.json --continueOnConflictingPaths true --includeDefinitions true From 049186661ffbdbc73aa356d5be6d56e81fbba83d Mon Sep 17 00:00:00 2001 From: anilCSE Date: Sat, 22 Aug 2020 17:00:16 +0530 Subject: [PATCH 13/27] refactor --- scripts/protocgen.sh | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-) diff --git a/scripts/protocgen.sh b/scripts/protocgen.sh index dddbe7deab6c..f2ccfb18adda 100755 --- a/scripts/protocgen.sh +++ b/scripts/protocgen.sh @@ -3,7 +3,6 @@ set -eo pipefail proto_files='' -query_files='' proto_dirs=$(find ./proto -path -prune -o -name '*.proto' -print0 | xargs -0 -n1 dirname | sort | uniq) for dir in $proto_dirs; do @@ -21,9 +20,9 @@ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. \ --grpc-gateway_out=logtostderr=true:. \ $(find "${dir}" -maxdepth 1 -name '*.proto') + # generate swagger only for query files query_file=$(find "${dir}" -maxdepth 1 -name 'query.proto') if [[ ! -z "$query_file" ]]; then - query_files=${query_files}" ${query_file}" protoc \ -I "proto" \ -I "third_party/proto" \ @@ -34,13 +33,6 @@ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. \ proto_files=${proto_files}" ${dir:2}/*.proto" done -#echo $query_files -#protoc \ -#-I "proto" \ -#-I "third_party/proto" \ -#$query_files \ -#--swagger_out=logtostderr=true,include_package_in_tags=true,fqn_for_swagger_name=true,allow_merge=true:. - # generate codec/testdata proto code protoc -I "proto" -I "third_party/proto" -I "testutil/testdata" --gocosmos_out=plugins=interfacetype+grpc,\ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. ./testutil/testdata/proto.proto From eeeca447e4ce4012ac20133cf58f53a3adb722d6 Mon Sep 17 00:00:00 2001 From: anilCSE Date: Sat, 22 Aug 2020 17:02:32 +0530 Subject: [PATCH 14/27] Add proto-gen-swagger installation tool --- contrib/devtools/Makefile | 3 +++ 1 file changed, 3 insertions(+) diff --git a/contrib/devtools/Makefile b/contrib/devtools/Makefile index 3557f345b75a..f1ada50302d4 100644 --- a/contrib/devtools/Makefile +++ b/contrib/devtools/Makefile @@ -101,6 +101,9 @@ proto-tools-stamp: @echo "Installing protoc-gen-grpc-gateway..." @go install github.com/grpc-ecosystem/grpc-gateway/protoc-gen-grpc-gateway + @echo "Installing protoc-gen-swagger..." + @go install github.com/grpc-ecosystem/grpc-gateway/protoc-gen-swagger + touch $@ buf: buf-stamp From 40d1eeeb0221040dfabe621c4bbd32c2e98c3a7c Mon Sep 17 00:00:00 2001 From: anilCSE Date: Sat, 22 Aug 2020 17:09:41 +0530 Subject: [PATCH 15/27] fix tool --- contrib/devtools/Makefile | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/contrib/devtools/Makefile b/contrib/devtools/Makefile index 832cef8ea2ad..850e99a40fb5 100644 --- a/contrib/devtools/Makefile +++ b/contrib/devtools/Makefile @@ -114,10 +114,13 @@ ifeq (, $(shell which protoc-gen-grpc-gateway)) else @echo "protoc-gen-grpc-gateway already installed; skipping..." endif - @go install github.com/grpc-ecosystem/grpc-gateway/protoc-gen-grpc-gateway +ifeq (, $(shell which protoc-gen-swagger)) @echo "Installing protoc-gen-swagger..." @go install github.com/grpc-ecosystem/grpc-gateway/protoc-gen-swagger +else + @echo "protoc-gen-grpc-gateway already installed; skipping..." +endif touch $@ From 3fe9a205e3706a6cd69747752354e4c7cfbf879c Mon Sep 17 00:00:00 2001 From: anilCSE Date: Sat, 22 Aug 2020 17:11:04 +0530 Subject: [PATCH 16/27] refactor --- contrib/devtools/Makefile | 2 -- scripts/protocgen.sh | 4 ---- 2 files changed, 6 deletions(-) diff --git a/contrib/devtools/Makefile b/contrib/devtools/Makefile index 850e99a40fb5..d1908690eb5a 100644 --- a/contrib/devtools/Makefile +++ b/contrib/devtools/Makefile @@ -122,8 +122,6 @@ else @echo "protoc-gen-grpc-gateway already installed; skipping..." endif - touch $@ - buf: buf-stamp buf-stamp: diff --git a/scripts/protocgen.sh b/scripts/protocgen.sh index f2ccfb18adda..77db73579050 100755 --- a/scripts/protocgen.sh +++ b/scripts/protocgen.sh @@ -2,8 +2,6 @@ set -eo pipefail -proto_files='' - proto_dirs=$(find ./proto -path -prune -o -name '*.proto' -print0 | xargs -0 -n1 dirname | sort | uniq) for dir in $proto_dirs; do protoc \ @@ -29,8 +27,6 @@ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. \ "$query_file" \ --swagger_out=logtostderr=true,stderrthreshold=1000,fqn_for_swagger_name=true,simple_operation_ids=true:. fi - - proto_files=${proto_files}" ${dir:2}/*.proto" done # generate codec/testdata proto code From 747e615f86f79ebe95ca92cc3cd1a622404286ef Mon Sep 17 00:00:00 2001 From: anilCSE Date: Sat, 22 Aug 2020 17:17:26 +0530 Subject: [PATCH 17/27] don't push individual swagger files to repo --- client/grpc-gateway/swagger.json | 357 ++--- cosmos/auth/v1beta1/query.swagger.json | 155 -- cosmos/bank/v1beta1/query.swagger.json | 377 ----- .../distribution/v1beta1/query.swagger.json | 628 -------- cosmos/evidence/v1beta1/query.swagger.json | 214 --- cosmos/gov/v1beta1/query.swagger.json | 785 ---------- cosmos/mint/v1beta1/query.swagger.json | 182 --- cosmos/params/v1beta1/query.swagger.json | 114 -- cosmos/slashing/v1beta1/query.swagger.json | 302 ---- cosmos/staking/v1beta1/query.swagger.json | 1385 ----------------- cosmos/upgrade/v1beta1/query.swagger.json | 150 -- ibc/channel/query.swagger.json | 982 ------------ ibc/connection/query.swagger.json | 520 ------- ibc/transfer/query.swagger.json | 273 ---- scripts/protocgen.sh | 8 +- 15 files changed, 155 insertions(+), 6277 deletions(-) delete mode 100644 cosmos/auth/v1beta1/query.swagger.json delete mode 100644 cosmos/bank/v1beta1/query.swagger.json delete mode 100644 cosmos/distribution/v1beta1/query.swagger.json delete mode 100644 cosmos/evidence/v1beta1/query.swagger.json delete mode 100644 cosmos/gov/v1beta1/query.swagger.json delete mode 100644 cosmos/mint/v1beta1/query.swagger.json delete mode 100644 cosmos/params/v1beta1/query.swagger.json delete mode 100644 cosmos/slashing/v1beta1/query.swagger.json delete mode 100644 cosmos/staking/v1beta1/query.swagger.json delete mode 100644 cosmos/upgrade/v1beta1/query.swagger.json delete mode 100644 ibc/channel/query.swagger.json delete mode 100644 ibc/connection/query.swagger.json delete mode 100644 ibc/transfer/query.swagger.json diff --git a/client/grpc-gateway/swagger.json b/client/grpc-gateway/swagger.json index 26000f77ae55..e6649a0e7c55 100644 --- a/client/grpc-gateway/swagger.json +++ b/client/grpc-gateway/swagger.json @@ -208,8 +208,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "description": "QueryAllBalancesResponse is the response type for the Query/AllBalances RPC method." @@ -404,7 +403,7 @@ "format": "boolean" } }, - "title": "Send enabled configuration properties for each denomination" + "description": "SendEnabled maps coin denom to a send_enabled status (whether a denom is sendable)." } }, "default_send_enabled": { @@ -412,7 +411,7 @@ "format": "boolean" } }, - "description": "Params defines the set of bank parameters." + "description": "Params defines the parameters for the bank module." } }, "description": "QueryParamsResponse defines the response type for querying x/bank parameters." @@ -704,7 +703,7 @@ } } }, - "description": "DelegationDelegatorReward defines the properties\nof a delegator's delegation reward." + "description": "DelegationDelegatorReward represents the properties\nof a delegator's delegation reward." }, "description": "rewards defines all the rewards accrued by a delegator." }, @@ -1104,8 +1103,7 @@ "description": "DecCoin defines a token with a denomination and a decimal amount.\n\nNOTE: The amount field is an Dec which implements the custom method\nsignatures required by gogoproto." } } - }, - "title": "accumulated commission for a validator\nkept as a running counter, can be withdrawn at any time" + } } }, "title": "QueryValidatorCommissionResponse is the response type for the Query/ValidatorCommission RPC method" @@ -1189,7 +1187,7 @@ } } }, - "title": "outstanding (un-withdrawn) rewards for a validator\ninexpensive to track, allows simple sanity checks" + "description": "ValidatorOutstandingRewards represents outstanding (un-withdrawn) rewards\nfor a validator inexpensive to track, allows simple sanity checks." } }, "description": "QueryValidatorOutstandingRewardsResponse is the response type for the Query/ValidatorOutstandingRewards RPC method." @@ -1267,7 +1265,7 @@ "type": "string" } }, - "title": "validator slash event\nheight is implicit within the store key\nneeded to calculate appropriate amounts of staking token\nfor delegations which withdraw after a slash has occurred" + "description": "ValidatorSlashEvent represents a validator slash event.\nHeight is implicit within the store key.\nThis is needed to calculate appropriate amount of staking tokens\nfor delegations which are withdrawn after a slash has occurred." }, "description": "slashes defines the slashes the validator received." }, @@ -1285,8 +1283,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "description": "QueryValidatorSlashesResponse is the response type for the Query/ValidatorSlashes RPC method." @@ -1432,8 +1429,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "description": "QueryAllEvidenceResponse is the response type for the Query/AllEvidence RPC method." @@ -1614,8 +1610,7 @@ "type": "string", "description": "Length of the voting period." } - }, - "title": "VotingParams defines the params around Voting in governance" + } }, "deposit_params": { "description": "deposit_params defines the parameters related to deposit.", @@ -1641,8 +1636,7 @@ "type": "string", "description": "Maximum period for Atom holders to deposit on a proposal. Initial value: 2 months." } - }, - "title": "DepositParams defines the params around deposits for governance" + } }, "tally_params": { "description": "tally_params defines the parameters related to tally.", @@ -1656,15 +1650,14 @@ "threshold": { "type": "string", "format": "byte", - "description": "Minimum proportion of Yes votes for proposal to pass. Initial value: 0.5." + "description": "Minimum proportion of Yes votes for proposal to pass. Default value: 0.5." }, - "veto": { + "veto_threshold": { "type": "string", "format": "byte", - "description": "Minimum value of Veto votes to Total votes ratio for proposal to be vetoed. Initial value: 1/3." + "description": "Minimum value of Veto votes to Total votes ratio for proposal to be vetoed. Default value: 1/3." } - }, - "title": "TallyParams defines the params around Tallying votes in governance" + } } }, "description": "QueryParamsResponse is the response type for the Query/Params RPC method." @@ -1766,8 +1759,7 @@ "PROPOSAL_STATUS_FAILED" ], "default": "PROPOSAL_STATUS_UNSPECIFIED", - "description": "- PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed.", - "title": "ProposalStatus is a type alias that represents a proposal status as a byte" + "description": "ProposalStatus enumerates the valid statuses of a proposal.\n\n - PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed." }, "final_tally_result": { "type": "object", @@ -1785,7 +1777,7 @@ "type": "string" } }, - "title": "TallyResult defines a standard tally for a proposal" + "description": "TallyResult defines a standard tally for a governance proposal." }, "submit_time": { "type": "string", @@ -1819,7 +1811,7 @@ "format": "date-time" } }, - "title": "Proposal defines the core field members of a governance proposal" + "description": "Proposal defines the core field members of a governance proposal." } }, "pagination": { @@ -1836,8 +1828,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "description": "QueryProposalsResponse is the response type for the Query/Proposals RPC method." @@ -1994,8 +1985,7 @@ "PROPOSAL_STATUS_FAILED" ], "default": "PROPOSAL_STATUS_UNSPECIFIED", - "description": "- PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed.", - "title": "ProposalStatus is a type alias that represents a proposal status as a byte" + "description": "ProposalStatus enumerates the valid statuses of a proposal.\n\n - PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed." }, "final_tally_result": { "type": "object", @@ -2013,7 +2003,7 @@ "type": "string" } }, - "title": "TallyResult defines a standard tally for a proposal" + "description": "TallyResult defines a standard tally for a governance proposal." }, "submit_time": { "type": "string", @@ -2047,7 +2037,7 @@ "format": "date-time" } }, - "title": "Proposal defines the core field members of a governance proposal" + "description": "Proposal defines the core field members of a governance proposal." } }, "description": "QueryProposalResponse is the response type for the Query/Proposal RPC method." @@ -2144,7 +2134,7 @@ } } }, - "title": "Deposit defines an amount deposited by an account address to an active proposal" + "description": "Deposit defines an amount deposited by an account address to an active proposal." } }, "pagination": { @@ -2161,8 +2151,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "description": "QueryDepositsResponse is the response type for the Query/Deposits RPC method." @@ -2289,8 +2278,7 @@ "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." } } - }, - "title": "Deposit defines an amount deposited by an account address to an active proposal" + } } }, "description": "QueryDepositResponse is the response type for the Query/Deposit RPC method." @@ -2382,8 +2370,7 @@ "no_with_veto": { "type": "string" } - }, - "title": "TallyResult defines a standard tally for a proposal" + } } }, "description": "QueryTallyResultResponse is the response type for the Query/Tally RPC method." @@ -2474,11 +2461,10 @@ "VOTE_OPTION_NO_WITH_VETO" ], "default": "VOTE_OPTION_UNSPECIFIED", - "description": "- VOTE_OPTION_UNSPECIFIED: VOTE_OPTION_UNSPECIFIED defines a no-op vote option.\n - VOTE_OPTION_YES: VOTE_OPTION_YES defines a yes vote option.\n - VOTE_OPTION_ABSTAIN: VOTE_OPTION_ABSTAIN defines an abstain vote option.\n - VOTE_OPTION_NO: VOTE_OPTION_NO defines a no vote option.\n - VOTE_OPTION_NO_WITH_VETO: VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option.", - "title": "VoteOption defines a vote option" + "description": "VoteOption enumerates the valid vote options for a given governance proposal.\n\n - VOTE_OPTION_UNSPECIFIED: VOTE_OPTION_UNSPECIFIED defines a no-op vote option.\n - VOTE_OPTION_YES: VOTE_OPTION_YES defines a yes vote option.\n - VOTE_OPTION_ABSTAIN: VOTE_OPTION_ABSTAIN defines an abstain vote option.\n - VOTE_OPTION_NO: VOTE_OPTION_NO defines a no vote option.\n - VOTE_OPTION_NO_WITH_VETO: VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option." } }, - "description": "Vote defines a vote on a governance proposal. A vote corresponds to a proposal\nID, the voter, and the vote option." + "description": "Vote defines a vote on a governance proposal.\nA Vote consists of a proposal ID, the voter, and the vote option." }, "description": "votes defined the queried votes." }, @@ -2496,8 +2482,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "description": "QueryVotesResponse is the response type for the Query/Votes RPC method." @@ -2619,8 +2604,7 @@ "VOTE_OPTION_NO_WITH_VETO" ], "default": "VOTE_OPTION_UNSPECIFIED", - "description": "- VOTE_OPTION_UNSPECIFIED: VOTE_OPTION_UNSPECIFIED defines a no-op vote option.\n - VOTE_OPTION_YES: VOTE_OPTION_YES defines a yes vote option.\n - VOTE_OPTION_ABSTAIN: VOTE_OPTION_ABSTAIN defines an abstain vote option.\n - VOTE_OPTION_NO: VOTE_OPTION_NO defines a no vote option.\n - VOTE_OPTION_NO_WITH_VETO: VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option.", - "title": "VoteOption defines a vote option" + "description": "VoteOption enumerates the valid vote options for a given governance proposal.\n\n - VOTE_OPTION_UNSPECIFIED: VOTE_OPTION_UNSPECIFIED defines a no-op vote option.\n - VOTE_OPTION_YES: VOTE_OPTION_YES defines a yes vote option.\n - VOTE_OPTION_ABSTAIN: VOTE_OPTION_ABSTAIN defines an abstain vote option.\n - VOTE_OPTION_NO: VOTE_OPTION_NO defines a no vote option.\n - VOTE_OPTION_NO_WITH_VETO: VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option." } } } @@ -2843,8 +2827,7 @@ "format": "uint64", "title": "expected blocks per year" } - }, - "title": "mint parameters" + } } }, "description": "QueryParamsResponse is the response type for the Query/Params RPC method." @@ -3006,7 +2989,7 @@ "format": "byte" } }, - "title": "Params - used for initializing default parameter for slashing at genesis" + "description": "Params represents the parameters used for by the slashing module." } }, "title": "QueryParamsResponse is the response type for the Query/Params RPC method" @@ -3096,7 +3079,7 @@ "title": "missed blocks counter (to avoid scanning the array every time)" } }, - "title": "ValidatorSigningInfo defines the signing info for a validator" + "description": "ValidatorSigningInfo defines a validator's signing info for monitoring their liveness activity." }, "title": "info is the signing info of all validators" }, @@ -3114,8 +3097,7 @@ "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } }, - "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + "description": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest.\n\n message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }" } }, "title": "QuerySigningInfosResponse is the response type for the Query/SigningInfos RPC method" @@ -3237,7 +3219,8 @@ "format": "int64", "title": "missed blocks counter (to avoid scanning the array every time)" } - } + }, + "description": "ValidatorSigningInfo defines a validator's signing info for monitoring their liveness activity." } }, "title": "QuerySigningInfoResponse is the response type for the Query/SigningInfo RPC method" @@ -3355,8 +3338,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "description": "QueryDelegatorDelegationsResponse is response type for the Query/DelegatorDelegations RPC method." @@ -3549,8 +3531,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "description": "QueryRedelegationsResponse is response type for the Query/Redelegations RPC method." @@ -3700,7 +3681,7 @@ } } }, - "title": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list" + "description": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list." } }, "pagination": { @@ -3717,8 +3698,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "description": "QueryUnbondingDelegatorDelegationsResponse is response type for the Query/UnbondingDelegatorDelegations RPC method." @@ -3893,13 +3873,13 @@ "format": "date-time" } }, - "description": "Commission defines a commission parameters for a given validator." + "description": "Commission defines commission parameters for a given validator." }, "min_self_delegation": { "type": "string" } }, - "description": "Validator defines the total amount of bond shares and their exchange rate to\ncoins. Slashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." + "description": "Validator defines a validator, together with the total amount of the Validator's\nbond shares and their exchange rate to coins.\nSlashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." }, "description": "validators defines the the validators' info of a delegator." }, @@ -3917,8 +3897,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "description": "QueryDelegatorValidatorsResponse is response type for the Query/DelegatorValidators RPC method." @@ -4092,7 +4071,7 @@ "format": "date-time" } }, - "description": "Commission defines a commission parameters for a given validator." + "description": "Commission defines commission parameters for a given validator." }, "min_self_delegation": { "type": "string" @@ -4347,13 +4326,13 @@ "format": "date-time" } }, - "description": "Commission defines a commission parameters for a given validator." + "description": "Commission defines commission parameters for a given validator." }, "min_self_delegation": { "type": "string" } }, - "description": "Validator defines the total amount of bond shares and their exchange rate to\ncoins. Slashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." + "description": "Validator defines a validator, together with the total amount of the Validator's\nbond shares and their exchange rate to coins.\nSlashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." } } } @@ -4508,8 +4487,7 @@ "bonded_tokens": { "type": "string" } - }, - "title": "Pool - tracking bonded and not-bonded token supply of the bond denomination" + } } }, "description": "QueryPoolResponse is response type for the Query/Pool RPC method." @@ -4642,13 +4620,13 @@ "format": "date-time" } }, - "description": "Commission defines a commission parameters for a given validator." + "description": "Commission defines commission parameters for a given validator." }, "min_self_delegation": { "type": "string" } }, - "description": "Validator defines the total amount of bond shares and their exchange rate to\ncoins. Slashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." + "description": "Validator defines a validator, together with the total amount of the Validator's\nbond shares and their exchange rate to coins.\nSlashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." }, "description": "validators contains all the queried validators." }, @@ -4666,8 +4644,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "title": "QueryValidatorsResponse is response type for the Query/Validators RPC method" @@ -4840,7 +4817,7 @@ "format": "date-time" } }, - "description": "Commission defines a commission parameters for a given validator." + "description": "Commission defines commission parameters for a given validator." }, "min_self_delegation": { "type": "string" @@ -4962,8 +4939,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "title": "QueryValidatorDelegationsResponse is response type for the Query/ValidatorDelegations RPC method" @@ -5201,8 +5177,7 @@ "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." } } - }, - "title": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list" + } } }, "description": "QueryDelegationResponse is response type for the Query/UnbondingDelegation RPC method." @@ -5312,7 +5287,7 @@ } } }, - "title": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list" + "description": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list." } }, "pagination": { @@ -5329,8 +5304,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "description": "QueryValidatorUnbondingDelegationsResponse is response type for the Query/ValidatorUnbondingDelegations RPC method." @@ -5516,8 +5490,7 @@ "type": "string", "title": "Any application specific upgrade info to be included on-chain\nsuch as a git commit that validators could automatically upgrade to" } - }, - "title": "Plan specifies information about a planned upgrade and when it should occur" + } } }, "description": "QueryCurrentPlanResponse is the response type for the Query/CurrentPlan RPC method." @@ -5707,7 +5680,7 @@ "format": "boolean" } }, - "title": "Send enabled configuration properties for each denomination" + "description": "SendEnabled maps coin denom to a send_enabled status (whether a denom is sendable)." } }, "default_send_enabled": { @@ -5715,7 +5688,7 @@ "format": "boolean" } }, - "description": "Params defines the set of bank parameters." + "description": "Params defines the parameters for the bank module." }, "cosmos.bank.v1beta1.QueryAllBalancesResponse": { "type": "object", @@ -5750,8 +5723,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "description": "QueryAllBalancesResponse is the response type for the Query/AllBalances RPC method." @@ -5793,7 +5765,7 @@ "format": "boolean" } }, - "title": "Send enabled configuration properties for each denomination" + "description": "SendEnabled maps coin denom to a send_enabled status (whether a denom is sendable)." } }, "default_send_enabled": { @@ -5801,7 +5773,7 @@ "format": "boolean" } }, - "description": "Params defines the set of bank parameters." + "description": "Params defines the parameters for the bank module." } }, "description": "QueryParamsResponse defines the response type for querying x/bank parameters." @@ -5857,7 +5829,7 @@ "format": "boolean" } }, - "title": "Send enabled configuration properties for each denomination" + "description": "SendEnabled maps coin denom to a send_enabled status (whether a denom is sendable)." }, "cosmos.base.query.v1beta1.PageRequest": { "type": "object", @@ -5900,8 +5872,7 @@ "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } }, - "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + "description": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest.\n\n message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }" }, "cosmos.base.v1beta1.Coin": { "type": "object", @@ -5950,7 +5921,7 @@ } } }, - "description": "DelegationDelegatorReward defines the properties\nof a delegator's delegation reward." + "description": "DelegationDelegatorReward represents the properties\nof a delegator's delegation reward." }, "cosmos.distribution.v1beta1.Params": { "type": "object", @@ -5969,7 +5940,7 @@ "format": "boolean" } }, - "description": "Params defines the set of distribution parameters." + "description": "Params defines the set of params for the distribution module." }, "cosmos.distribution.v1beta1.QueryCommunityPoolResponse": { "type": "object", @@ -6043,7 +6014,7 @@ } } }, - "description": "DelegationDelegatorReward defines the properties\nof a delegator's delegation reward." + "description": "DelegationDelegatorReward represents the properties\nof a delegator's delegation reward." }, "description": "rewards defines all the rewards accrued by a delegator." }, @@ -6138,8 +6109,7 @@ "description": "DecCoin defines a token with a denomination and a decimal amount.\n\nNOTE: The amount field is an Dec which implements the custom method\nsignatures required by gogoproto." } } - }, - "title": "accumulated commission for a validator\nkept as a running counter, can be withdrawn at any time" + } } }, "title": "QueryValidatorCommissionResponse is the response type for the Query/ValidatorCommission RPC method" @@ -6166,7 +6136,7 @@ } } }, - "title": "outstanding (un-withdrawn) rewards for a validator\ninexpensive to track, allows simple sanity checks" + "description": "ValidatorOutstandingRewards represents outstanding (un-withdrawn) rewards\nfor a validator inexpensive to track, allows simple sanity checks." } }, "description": "QueryValidatorOutstandingRewardsResponse is the response type for the Query/ValidatorOutstandingRewards RPC method." @@ -6187,7 +6157,7 @@ "type": "string" } }, - "title": "validator slash event\nheight is implicit within the store key\nneeded to calculate appropriate amounts of staking token\nfor delegations which withdraw after a slash has occurred" + "description": "ValidatorSlashEvent represents a validator slash event.\nHeight is implicit within the store key.\nThis is needed to calculate appropriate amount of staking tokens\nfor delegations which are withdrawn after a slash has occurred." }, "description": "slashes defines the slashes the validator received." }, @@ -6205,8 +6175,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "description": "QueryValidatorSlashesResponse is the response type for the Query/ValidatorSlashes RPC method." @@ -6230,7 +6199,7 @@ } } }, - "title": "accumulated commission for a validator\nkept as a running counter, can be withdrawn at any time" + "description": "ValidatorAccumulatedCommission represents accumulated commission\nfor a validator kept as a running counter, can be withdrawn at any time." }, "cosmos.distribution.v1beta1.ValidatorOutstandingRewards": { "type": "object", @@ -6251,7 +6220,7 @@ } } }, - "title": "outstanding (un-withdrawn) rewards for a validator\ninexpensive to track, allows simple sanity checks" + "description": "ValidatorOutstandingRewards represents outstanding (un-withdrawn) rewards\nfor a validator inexpensive to track, allows simple sanity checks." }, "cosmos.distribution.v1beta1.ValidatorSlashEvent": { "type": "object", @@ -6264,7 +6233,7 @@ "type": "string" } }, - "title": "validator slash event\nheight is implicit within the store key\nneeded to calculate appropriate amounts of staking token\nfor delegations which withdraw after a slash has occurred" + "description": "ValidatorSlashEvent represents a validator slash event.\nHeight is implicit within the store key.\nThis is needed to calculate appropriate amount of staking tokens\nfor delegations which are withdrawn after a slash has occurred." }, "cosmos.evidence.v1beta1.QueryAllEvidenceResponse": { "type": "object", @@ -6302,8 +6271,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "description": "QueryAllEvidenceResponse is the response type for the Query/AllEvidence RPC method." @@ -6356,7 +6324,7 @@ } } }, - "title": "Deposit defines an amount deposited by an account address to an active proposal" + "description": "Deposit defines an amount deposited by an account address to an active proposal." }, "cosmos.gov.v1beta1.DepositParams": { "type": "object", @@ -6382,7 +6350,7 @@ "description": "Maximum period for Atom holders to deposit on a proposal. Initial value: 2 months." } }, - "title": "DepositParams defines the params around deposits for governance" + "description": "DepositParams defines the params for deposits on governance proposals." }, "cosmos.gov.v1beta1.Proposal": { "type": "object", @@ -6417,8 +6385,7 @@ "PROPOSAL_STATUS_FAILED" ], "default": "PROPOSAL_STATUS_UNSPECIFIED", - "description": "- PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed.", - "title": "ProposalStatus is a type alias that represents a proposal status as a byte" + "description": "ProposalStatus enumerates the valid statuses of a proposal.\n\n - PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed." }, "final_tally_result": { "type": "object", @@ -6436,7 +6403,7 @@ "type": "string" } }, - "title": "TallyResult defines a standard tally for a proposal" + "description": "TallyResult defines a standard tally for a governance proposal." }, "submit_time": { "type": "string", @@ -6470,7 +6437,7 @@ "format": "date-time" } }, - "title": "Proposal defines the core field members of a governance proposal" + "description": "Proposal defines the core field members of a governance proposal." }, "cosmos.gov.v1beta1.ProposalStatus": { "type": "string", @@ -6483,8 +6450,7 @@ "PROPOSAL_STATUS_FAILED" ], "default": "PROPOSAL_STATUS_UNSPECIFIED", - "description": "- PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed.", - "title": "ProposalStatus is a type alias that represents a proposal status as a byte" + "description": "ProposalStatus enumerates the valid statuses of a proposal.\n\n - PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed." }, "cosmos.gov.v1beta1.QueryDepositResponse": { "type": "object", @@ -6516,8 +6482,7 @@ "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." } } - }, - "title": "Deposit defines an amount deposited by an account address to an active proposal" + } } }, "description": "QueryDepositResponse is the response type for the Query/Deposit RPC method." @@ -6554,7 +6519,7 @@ } } }, - "title": "Deposit defines an amount deposited by an account address to an active proposal" + "description": "Deposit defines an amount deposited by an account address to an active proposal." } }, "pagination": { @@ -6571,8 +6536,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "description": "QueryDepositsResponse is the response type for the Query/Deposits RPC method." @@ -6588,8 +6552,7 @@ "type": "string", "description": "Length of the voting period." } - }, - "title": "VotingParams defines the params around Voting in governance" + } }, "deposit_params": { "description": "deposit_params defines the parameters related to deposit.", @@ -6615,8 +6578,7 @@ "type": "string", "description": "Maximum period for Atom holders to deposit on a proposal. Initial value: 2 months." } - }, - "title": "DepositParams defines the params around deposits for governance" + } }, "tally_params": { "description": "tally_params defines the parameters related to tally.", @@ -6630,15 +6592,14 @@ "threshold": { "type": "string", "format": "byte", - "description": "Minimum proportion of Yes votes for proposal to pass. Initial value: 0.5." + "description": "Minimum proportion of Yes votes for proposal to pass. Default value: 0.5." }, - "veto": { + "veto_threshold": { "type": "string", "format": "byte", - "description": "Minimum value of Veto votes to Total votes ratio for proposal to be vetoed. Initial value: 1/3." + "description": "Minimum value of Veto votes to Total votes ratio for proposal to be vetoed. Default value: 1/3." } - }, - "title": "TallyParams defines the params around Tallying votes in governance" + } } }, "description": "QueryParamsResponse is the response type for the Query/Params RPC method." @@ -6679,8 +6640,7 @@ "PROPOSAL_STATUS_FAILED" ], "default": "PROPOSAL_STATUS_UNSPECIFIED", - "description": "- PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed.", - "title": "ProposalStatus is a type alias that represents a proposal status as a byte" + "description": "ProposalStatus enumerates the valid statuses of a proposal.\n\n - PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed." }, "final_tally_result": { "type": "object", @@ -6698,7 +6658,7 @@ "type": "string" } }, - "title": "TallyResult defines a standard tally for a proposal" + "description": "TallyResult defines a standard tally for a governance proposal." }, "submit_time": { "type": "string", @@ -6732,7 +6692,7 @@ "format": "date-time" } }, - "title": "Proposal defines the core field members of a governance proposal" + "description": "Proposal defines the core field members of a governance proposal." } }, "description": "QueryProposalResponse is the response type for the Query/Proposal RPC method." @@ -6775,8 +6735,7 @@ "PROPOSAL_STATUS_FAILED" ], "default": "PROPOSAL_STATUS_UNSPECIFIED", - "description": "- PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed.", - "title": "ProposalStatus is a type alias that represents a proposal status as a byte" + "description": "ProposalStatus enumerates the valid statuses of a proposal.\n\n - PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed." }, "final_tally_result": { "type": "object", @@ -6794,7 +6753,7 @@ "type": "string" } }, - "title": "TallyResult defines a standard tally for a proposal" + "description": "TallyResult defines a standard tally for a governance proposal." }, "submit_time": { "type": "string", @@ -6828,7 +6787,7 @@ "format": "date-time" } }, - "title": "Proposal defines the core field members of a governance proposal" + "description": "Proposal defines the core field members of a governance proposal." } }, "pagination": { @@ -6845,8 +6804,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "description": "QueryProposalsResponse is the response type for the Query/Proposals RPC method." @@ -6870,8 +6828,7 @@ "no_with_veto": { "type": "string" } - }, - "title": "TallyResult defines a standard tally for a proposal" + } } }, "description": "QueryTallyResultResponse is the response type for the Query/Tally RPC method." @@ -6901,8 +6858,7 @@ "VOTE_OPTION_NO_WITH_VETO" ], "default": "VOTE_OPTION_UNSPECIFIED", - "description": "- VOTE_OPTION_UNSPECIFIED: VOTE_OPTION_UNSPECIFIED defines a no-op vote option.\n - VOTE_OPTION_YES: VOTE_OPTION_YES defines a yes vote option.\n - VOTE_OPTION_ABSTAIN: VOTE_OPTION_ABSTAIN defines an abstain vote option.\n - VOTE_OPTION_NO: VOTE_OPTION_NO defines a no vote option.\n - VOTE_OPTION_NO_WITH_VETO: VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option.", - "title": "VoteOption defines a vote option" + "description": "VoteOption enumerates the valid vote options for a given governance proposal.\n\n - VOTE_OPTION_UNSPECIFIED: VOTE_OPTION_UNSPECIFIED defines a no-op vote option.\n - VOTE_OPTION_YES: VOTE_OPTION_YES defines a yes vote option.\n - VOTE_OPTION_ABSTAIN: VOTE_OPTION_ABSTAIN defines an abstain vote option.\n - VOTE_OPTION_NO: VOTE_OPTION_NO defines a no vote option.\n - VOTE_OPTION_NO_WITH_VETO: VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option." } } } @@ -6935,11 +6891,10 @@ "VOTE_OPTION_NO_WITH_VETO" ], "default": "VOTE_OPTION_UNSPECIFIED", - "description": "- VOTE_OPTION_UNSPECIFIED: VOTE_OPTION_UNSPECIFIED defines a no-op vote option.\n - VOTE_OPTION_YES: VOTE_OPTION_YES defines a yes vote option.\n - VOTE_OPTION_ABSTAIN: VOTE_OPTION_ABSTAIN defines an abstain vote option.\n - VOTE_OPTION_NO: VOTE_OPTION_NO defines a no vote option.\n - VOTE_OPTION_NO_WITH_VETO: VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option.", - "title": "VoteOption defines a vote option" + "description": "VoteOption enumerates the valid vote options for a given governance proposal.\n\n - VOTE_OPTION_UNSPECIFIED: VOTE_OPTION_UNSPECIFIED defines a no-op vote option.\n - VOTE_OPTION_YES: VOTE_OPTION_YES defines a yes vote option.\n - VOTE_OPTION_ABSTAIN: VOTE_OPTION_ABSTAIN defines an abstain vote option.\n - VOTE_OPTION_NO: VOTE_OPTION_NO defines a no vote option.\n - VOTE_OPTION_NO_WITH_VETO: VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option." } }, - "description": "Vote defines a vote on a governance proposal. A vote corresponds to a proposal\nID, the voter, and the vote option." + "description": "Vote defines a vote on a governance proposal.\nA Vote consists of a proposal ID, the voter, and the vote option." }, "description": "votes defined the queried votes." }, @@ -6957,8 +6912,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "description": "QueryVotesResponse is the response type for the Query/Votes RPC method." @@ -6974,15 +6928,15 @@ "threshold": { "type": "string", "format": "byte", - "description": "Minimum proportion of Yes votes for proposal to pass. Initial value: 0.5." + "description": "Minimum proportion of Yes votes for proposal to pass. Default value: 0.5." }, - "veto": { + "veto_threshold": { "type": "string", "format": "byte", - "description": "Minimum value of Veto votes to Total votes ratio for proposal to be vetoed. Initial value: 1/3." + "description": "Minimum value of Veto votes to Total votes ratio for proposal to be vetoed. Default value: 1/3." } }, - "title": "TallyParams defines the params around Tallying votes in governance" + "description": "TallyParams defines the params for tallying votes on governance proposals." }, "cosmos.gov.v1beta1.TallyResult": { "type": "object", @@ -7000,7 +6954,7 @@ "type": "string" } }, - "title": "TallyResult defines a standard tally for a proposal" + "description": "TallyResult defines a standard tally for a governance proposal." }, "cosmos.gov.v1beta1.Vote": { "type": "object", @@ -7023,11 +6977,10 @@ "VOTE_OPTION_NO_WITH_VETO" ], "default": "VOTE_OPTION_UNSPECIFIED", - "description": "- VOTE_OPTION_UNSPECIFIED: VOTE_OPTION_UNSPECIFIED defines a no-op vote option.\n - VOTE_OPTION_YES: VOTE_OPTION_YES defines a yes vote option.\n - VOTE_OPTION_ABSTAIN: VOTE_OPTION_ABSTAIN defines an abstain vote option.\n - VOTE_OPTION_NO: VOTE_OPTION_NO defines a no vote option.\n - VOTE_OPTION_NO_WITH_VETO: VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option.", - "title": "VoteOption defines a vote option" + "description": "VoteOption enumerates the valid vote options for a given governance proposal.\n\n - VOTE_OPTION_UNSPECIFIED: VOTE_OPTION_UNSPECIFIED defines a no-op vote option.\n - VOTE_OPTION_YES: VOTE_OPTION_YES defines a yes vote option.\n - VOTE_OPTION_ABSTAIN: VOTE_OPTION_ABSTAIN defines an abstain vote option.\n - VOTE_OPTION_NO: VOTE_OPTION_NO defines a no vote option.\n - VOTE_OPTION_NO_WITH_VETO: VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option." } }, - "description": "Vote defines a vote on a governance proposal. A vote corresponds to a proposal\nID, the voter, and the vote option." + "description": "Vote defines a vote on a governance proposal.\nA Vote consists of a proposal ID, the voter, and the vote option." }, "cosmos.gov.v1beta1.VoteOption": { "type": "string", @@ -7039,8 +6992,7 @@ "VOTE_OPTION_NO_WITH_VETO" ], "default": "VOTE_OPTION_UNSPECIFIED", - "description": "- VOTE_OPTION_UNSPECIFIED: VOTE_OPTION_UNSPECIFIED defines a no-op vote option.\n - VOTE_OPTION_YES: VOTE_OPTION_YES defines a yes vote option.\n - VOTE_OPTION_ABSTAIN: VOTE_OPTION_ABSTAIN defines an abstain vote option.\n - VOTE_OPTION_NO: VOTE_OPTION_NO defines a no vote option.\n - VOTE_OPTION_NO_WITH_VETO: VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option.", - "title": "VoteOption defines a vote option" + "description": "VoteOption enumerates the valid vote options for a given governance proposal.\n\n - VOTE_OPTION_UNSPECIFIED: VOTE_OPTION_UNSPECIFIED defines a no-op vote option.\n - VOTE_OPTION_YES: VOTE_OPTION_YES defines a yes vote option.\n - VOTE_OPTION_ABSTAIN: VOTE_OPTION_ABSTAIN defines an abstain vote option.\n - VOTE_OPTION_NO: VOTE_OPTION_NO defines a no vote option.\n - VOTE_OPTION_NO_WITH_VETO: VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option." }, "cosmos.gov.v1beta1.VotingParams": { "type": "object", @@ -7050,7 +7002,7 @@ "description": "Length of the voting period." } }, - "title": "VotingParams defines the params around Voting in governance" + "description": "VotingParams defines the params for voting on governance proposals." }, "cosmos.mint.v1beta1.Params": { "type": "object", @@ -7081,7 +7033,7 @@ "title": "expected blocks per year" } }, - "title": "mint parameters" + "description": "Params holds parameters for the mint module." }, "cosmos.mint.v1beta1.QueryAnnualProvisionsResponse": { "type": "object", @@ -7137,8 +7089,7 @@ "format": "uint64", "title": "expected blocks per year" } - }, - "title": "mint parameters" + } } }, "description": "QueryParamsResponse is the response type for the Query/Params RPC method." @@ -7156,7 +7107,7 @@ "type": "string" } }, - "description": "ParamChange defines a parameter change." + "description": "ParamChange defines an individual parameter change, for use in ParameterChangeProposal." }, "cosmos.params.v1beta1.QueryParamsResponse": { "type": "object", @@ -7202,7 +7153,7 @@ "format": "byte" } }, - "title": "Params - used for initializing default parameter for slashing at genesis" + "description": "Params represents the parameters used for by the slashing module." }, "cosmos.slashing.v1beta1.QueryParamsResponse": { "type": "object", @@ -7230,7 +7181,7 @@ "format": "byte" } }, - "title": "Params - used for initializing default parameter for slashing at genesis" + "description": "Params represents the parameters used for by the slashing module." } }, "title": "QueryParamsResponse is the response type for the Query/Params RPC method" @@ -7271,7 +7222,8 @@ "format": "int64", "title": "missed blocks counter (to avoid scanning the array every time)" } - } + }, + "description": "ValidatorSigningInfo defines a validator's signing info for monitoring their liveness activity." } }, "title": "QuerySigningInfoResponse is the response type for the Query/SigningInfo RPC method" @@ -7314,7 +7266,7 @@ "title": "missed blocks counter (to avoid scanning the array every time)" } }, - "title": "ValidatorSigningInfo defines the signing info for a validator" + "description": "ValidatorSigningInfo defines a validator's signing info for monitoring their liveness activity." }, "title": "info is the signing info of all validators" }, @@ -7332,8 +7284,7 @@ "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } }, - "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + "description": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest.\n\n message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }" } }, "title": "QuerySigningInfosResponse is the response type for the Query/SigningInfos RPC method" @@ -7371,7 +7322,7 @@ "title": "missed blocks counter (to avoid scanning the array every time)" } }, - "title": "ValidatorSigningInfo defines the signing info for a validator" + "description": "ValidatorSigningInfo defines a validator's signing info for monitoring their liveness activity." }, "cosmos.staking.v1beta1.Commission": { "type": "object", @@ -7396,7 +7347,7 @@ "format": "date-time" } }, - "description": "Commission defines a commission parameters for a given validator." + "description": "Commission defines commission parameters for a given validator." }, "cosmos.staking.v1beta1.CommissionRates": { "type": "object", @@ -7662,17 +7613,17 @@ "format": "date-time" } }, - "description": "Commission defines a commission parameters for a given validator." + "description": "Commission defines commission parameters for a given validator." }, "min_self_delegation": { "type": "string" } }, - "description": "Validator defines the total amount of bond shares and their exchange rate to\ncoins. Slashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." + "description": "Validator defines a validator, together with the total amount of the Validator's\nbond shares and their exchange rate to coins.\nSlashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." } } }, - "description": "HistoricalInfo contains the historical information that gets stored at\neach height." + "description": "HistoricalInfo contains header and validator information for a given block. It is stored\nas part of staking module's state, which persists the `n` most recent HistoricalInfo\n(`n` is set by the staking module's `historical_entries` parameter)." }, "cosmos.staking.v1beta1.Params": { "type": "object", @@ -7708,7 +7659,7 @@ "type": "string" } }, - "title": "Pool - tracking bonded and not-bonded token supply of the bond denomination" + "description": "Pool is used for tracking bonded and not-bonded token supply of the bond denomination." }, "cosmos.staking.v1beta1.QueryDelegationResponse": { "type": "object", @@ -7807,8 +7758,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "description": "QueryDelegatorDelegationsResponse is response type for the Query/DelegatorDelegations RPC method." @@ -7853,7 +7803,7 @@ } } }, - "title": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list" + "description": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list." } }, "pagination": { @@ -7870,8 +7820,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "description": "QueryUnbondingDelegatorDelegationsResponse is response type for the Query/UnbondingDelegatorDelegations RPC method." @@ -7956,7 +7905,7 @@ "format": "date-time" } }, - "description": "Commission defines a commission parameters for a given validator." + "description": "Commission defines commission parameters for a given validator." }, "min_self_delegation": { "type": "string" @@ -8047,13 +7996,13 @@ "format": "date-time" } }, - "description": "Commission defines a commission parameters for a given validator." + "description": "Commission defines commission parameters for a given validator." }, "min_self_delegation": { "type": "string" } }, - "description": "Validator defines the total amount of bond shares and their exchange rate to\ncoins. Slashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." + "description": "Validator defines a validator, together with the total amount of the Validator's\nbond shares and their exchange rate to coins.\nSlashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." }, "description": "validators defines the the validators' info of a delegator." }, @@ -8071,8 +8020,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "description": "QueryDelegatorValidatorsResponse is response type for the Query/DelegatorValidators RPC method." @@ -8257,13 +8205,13 @@ "format": "date-time" } }, - "description": "Commission defines a commission parameters for a given validator." + "description": "Commission defines commission parameters for a given validator." }, "min_self_delegation": { "type": "string" } }, - "description": "Validator defines the total amount of bond shares and their exchange rate to\ncoins. Slashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." + "description": "Validator defines a validator, together with the total amount of the Validator's\nbond shares and their exchange rate to coins.\nSlashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." } } } @@ -8314,8 +8262,7 @@ "bonded_tokens": { "type": "string" } - }, - "title": "Pool - tracking bonded and not-bonded token supply of the bond denomination" + } } }, "description": "QueryPoolResponse is response type for the Query/Pool RPC method." @@ -8419,8 +8366,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "description": "QueryRedelegationsResponse is response type for the Query/Redelegations RPC method." @@ -8463,8 +8409,7 @@ "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." } } - }, - "title": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list" + } } }, "description": "QueryDelegationResponse is response type for the Query/UnbondingDelegation RPC method." @@ -8524,8 +8469,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "title": "QueryValidatorDelegationsResponse is response type for the Query/ValidatorDelegations RPC method" @@ -8610,7 +8554,7 @@ "format": "date-time" } }, - "description": "Commission defines a commission parameters for a given validator." + "description": "Commission defines commission parameters for a given validator." }, "min_self_delegation": { "type": "string" @@ -8660,7 +8604,7 @@ } } }, - "title": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list" + "description": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list." } }, "pagination": { @@ -8677,8 +8621,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "description": "QueryValidatorUnbondingDelegationsResponse is response type for the Query/ValidatorUnbondingDelegations RPC method." @@ -8764,13 +8707,13 @@ "format": "date-time" } }, - "description": "Commission defines a commission parameters for a given validator." + "description": "Commission defines commission parameters for a given validator." }, "min_self_delegation": { "type": "string" } }, - "description": "Validator defines the total amount of bond shares and their exchange rate to\ncoins. Slashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." + "description": "Validator defines a validator, together with the total amount of the Validator's\nbond shares and their exchange rate to coins.\nSlashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." }, "description": "validators contains all the queried validators." }, @@ -8788,8 +8731,7 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - }, - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" + } } }, "title": "QueryValidatorsResponse is response type for the Query/Validators RPC method" @@ -8998,7 +8940,7 @@ } } }, - "title": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list" + "description": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list." }, "cosmos.staking.v1beta1.UnbondingDelegationEntry": { "type": "object", @@ -9096,13 +9038,13 @@ "format": "date-time" } }, - "description": "Commission defines a commission parameters for a given validator." + "description": "Commission defines commission parameters for a given validator." }, "min_self_delegation": { "type": "string" } }, - "description": "Validator defines the total amount of bond shares and their exchange rate to\ncoins. Slashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." + "description": "Validator defines a validator, together with the total amount of the Validator's\nbond shares and their exchange rate to coins.\nSlashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." }, "tendermint.types.BlockID": { "type": "object", @@ -9273,7 +9215,7 @@ "title": "Any application specific upgrade info to be included on-chain\nsuch as a git commit that validators could automatically upgrade to" } }, - "title": "Plan specifies information about a planned upgrade and when it should occur" + "description": "Plan specifies information about a planned upgrade and when it should occur." }, "cosmos.upgrade.v1beta1.QueryAppliedPlanResponse": { "type": "object", @@ -9311,8 +9253,7 @@ "type": "string", "title": "Any application specific upgrade info to be included on-chain\nsuch as a git commit that validators could automatically upgrade to" } - }, - "title": "Plan specifies information about a planned upgrade and when it should occur" + } } }, "description": "QueryCurrentPlanResponse is the response type for the Query/CurrentPlan RPC method." diff --git a/cosmos/auth/v1beta1/query.swagger.json b/cosmos/auth/v1beta1/query.swagger.json deleted file mode 100644 index da7c339eee3a..000000000000 --- a/cosmos/auth/v1beta1/query.swagger.json +++ /dev/null @@ -1,155 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "cosmos/auth/v1beta1/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/cosmos/auth/v1beta1/accounts/{address}": { - "get": { - "summary": "Account returns account details based on address.", - "operationId": "Account", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.auth.v1beta1.QueryAccountResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "address", - "description": "address defines the address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/auth/v1beta1/params": { - "get": { - "summary": "Params queries all parameters.", - "operationId": "Params", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.auth.v1beta1.QueryParamsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "cosmos.auth.v1beta1.Params": { - "type": "object", - "properties": { - "max_memo_characters": { - "type": "string", - "format": "uint64" - }, - "tx_sig_limit": { - "type": "string", - "format": "uint64" - }, - "tx_size_cost_per_byte": { - "type": "string", - "format": "uint64" - }, - "sig_verify_cost_ed25519": { - "type": "string", - "format": "uint64" - }, - "sig_verify_cost_secp256k1": { - "type": "string", - "format": "uint64" - } - }, - "description": "Params defines the parameters for the auth module." - }, - "cosmos.auth.v1beta1.QueryAccountResponse": { - "type": "object", - "properties": { - "account": { - "$ref": "#/definitions/google.protobuf.Any", - "description": "account defines the account of the corresponding address." - } - }, - "description": "QueryAccountResponse is the response type for the Query/Account RPC method." - }, - "cosmos.auth.v1beta1.QueryParamsResponse": { - "type": "object", - "properties": { - "params": { - "$ref": "#/definitions/cosmos.auth.v1beta1.Params", - "description": "params defines the parameters of the module." - } - }, - "description": "QueryParamsResponse is the response type for the Query/Params RPC method." - }, - "google.protobuf.Any": { - "type": "object", - "properties": { - "type_url": { - "type": "string", - "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." - }, - "value": { - "type": "string", - "format": "byte", - "description": "Must be a valid serialized protocol buffer of the above specified type." - } - }, - "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := \u0026pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" - }, - "grpc.gateway.runtime.Error": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/google.protobuf.Any" - } - } - } - } - } -} diff --git a/cosmos/bank/v1beta1/query.swagger.json b/cosmos/bank/v1beta1/query.swagger.json deleted file mode 100644 index 34c225b38e5b..000000000000 --- a/cosmos/bank/v1beta1/query.swagger.json +++ /dev/null @@ -1,377 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "cosmos/bank/v1beta1/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/cosmos/bank/v1beta1/balances/{address}": { - "get": { - "summary": "AllBalances queries the balance of all coins for a single account.", - "operationId": "AllBalances", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.bank.v1beta1.QueryAllBalancesResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "address", - "description": "address is the address to query balances for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/bank/v1beta1/balances/{address}/{denom}": { - "get": { - "summary": "Balance queries the balance of a single coin for a single account.", - "operationId": "Balance", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.bank.v1beta1.QueryBalanceResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "address", - "description": "address is the address to query balances for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "denom", - "description": "denom is the coin denom to query balances for.", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/bank/v1beta1/params": { - "get": { - "summary": "Params queries the parameters of x/bank module.", - "operationId": "Params", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.bank.v1beta1.QueryParamsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "tags": [ - "Query" - ] - } - }, - "/cosmos/bank/v1beta1/supply": { - "get": { - "summary": "TotalSupply queries the total supply of all coins.", - "operationId": "TotalSupply", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.bank.v1beta1.QueryTotalSupplyResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "tags": [ - "Query" - ] - } - }, - "/cosmos/bank/v1beta1/supply/{denom}": { - "get": { - "summary": "SupplyOf queries the supply of a single coin.", - "operationId": "SupplyOf", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.bank.v1beta1.QuerySupplyOfResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "denom", - "description": "denom is the coin denom to query balances for.", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "cosmos.bank.v1beta1.Params": { - "type": "object", - "properties": { - "send_enabled": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.bank.v1beta1.SendEnabled" - } - }, - "default_send_enabled": { - "type": "boolean", - "format": "boolean" - } - }, - "description": "Params defines the set of bank parameters." - }, - "cosmos.bank.v1beta1.QueryAllBalancesResponse": { - "type": "object", - "properties": { - "balances": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.base.v1beta1.Coin" - }, - "description": "balances is the balances of all the coins." - }, - "pagination": { - "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryAllBalancesResponse is the response type for the Query/AllBalances RPC method." - }, - "cosmos.bank.v1beta1.QueryBalanceResponse": { - "type": "object", - "properties": { - "balance": { - "$ref": "#/definitions/cosmos.base.v1beta1.Coin", - "description": "balance is the balance of the coin." - } - }, - "description": "QueryBalanceResponse is the response type for the Query/Balance RPC method." - }, - "cosmos.bank.v1beta1.QueryParamsResponse": { - "type": "object", - "properties": { - "params": { - "$ref": "#/definitions/cosmos.bank.v1beta1.Params" - } - }, - "description": "QueryParamsResponse defines the response type for querying x/bank parameters." - }, - "cosmos.bank.v1beta1.QuerySupplyOfResponse": { - "type": "object", - "properties": { - "amount": { - "$ref": "#/definitions/cosmos.base.v1beta1.Coin", - "description": "amount is the supply of the coin." - } - }, - "description": "QuerySupplyOfResponse is the response type for the Query/SupplyOf RPC method." - }, - "cosmos.bank.v1beta1.QueryTotalSupplyResponse": { - "type": "object", - "properties": { - "supply": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.base.v1beta1.Coin" - }, - "title": "supply is the supply of the coins" - } - }, - "title": "QueryTotalSupplyResponse is the response type for the Query/TotalSupply RPC method" - }, - "cosmos.bank.v1beta1.SendEnabled": { - "type": "object", - "properties": { - "denom": { - "type": "string" - }, - "enabled": { - "type": "boolean", - "format": "boolean" - } - }, - "title": "Send enabled configuration properties for each denomination" - }, - "cosmos.base.query.v1beta1.PageRequest": { - "type": "object", - "properties": { - "key": { - "type": "string", - "format": "byte", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." - }, - "offset": { - "type": "string", - "format": "uint64", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." - }, - "limit": { - "type": "string", - "format": "uint64", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." - }, - "count_total": { - "type": "boolean", - "format": "boolean", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." - } - }, - "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", - "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" - }, - "cosmos.base.query.v1beta1.PageResponse": { - "type": "object", - "properties": { - "next_key": { - "type": "string", - "format": "byte", - "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" - }, - "total": { - "type": "string", - "format": "uint64", - "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" - } - }, - "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" - }, - "cosmos.base.v1beta1.Coin": { - "type": "object", - "properties": { - "denom": { - "type": "string" - }, - "amount": { - "type": "string" - } - }, - "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." - }, - "google.protobuf.Any": { - "type": "object", - "properties": { - "type_url": { - "type": "string" - }, - "value": { - "type": "string", - "format": "byte" - } - } - }, - "grpc.gateway.runtime.Error": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/google.protobuf.Any" - } - } - } - } - } -} diff --git a/cosmos/distribution/v1beta1/query.swagger.json b/cosmos/distribution/v1beta1/query.swagger.json deleted file mode 100644 index 5980fcd4548a..000000000000 --- a/cosmos/distribution/v1beta1/query.swagger.json +++ /dev/null @@ -1,628 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "cosmos/distribution/v1beta1/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/cosmos/distribution/v1beta1/community_pool": { - "get": { - "summary": "CommunityPool queries the community pool coins.", - "operationId": "CommunityPool", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.distribution.v1beta1.QueryCommunityPoolResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "tags": [ - "Query" - ] - } - }, - "/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards": { - "get": { - "summary": "DelegationTotalRewards queries the total rewards accrued by a each validator.", - "operationId": "DelegationTotalRewards", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.distribution.v1beta1.QueryDelegationTotalRewardsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "delegator_address", - "description": "delegator_address defines the delegator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/distribution/v1beta1/delegators/{delegator_address}/rewards/{validator_address}": { - "get": { - "summary": "DelegationRewards queries the total rewards accrued by a delegation.", - "operationId": "DelegationRewards", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.distribution.v1beta1.QueryDelegationRewardsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "delegator_address", - "description": "delegator_address defines the delegator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "validator_address", - "description": "validator_address defines the validator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/distribution/v1beta1/delegators/{delegator_address}/validators": { - "get": { - "summary": "DelegatorValidators queries the validators of a delegator.", - "operationId": "DelegatorValidators", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.distribution.v1beta1.QueryDelegatorValidatorsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "delegator_address", - "description": "delegator_address defines the delegator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/distribution/v1beta1/delegators/{delegator_address}/withdraw_address": { - "get": { - "summary": "DelegatorWithdrawAddress queries withdraw address of a delegator.", - "operationId": "DelegatorWithdrawAddress", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.distribution.v1beta1.QueryDelegatorWithdrawAddressResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "delegator_address", - "description": "delegator_address defines the delegator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/distribution/v1beta1/params": { - "get": { - "summary": "Params queries params of the distribution module.", - "operationId": "Params", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.distribution.v1beta1.QueryParamsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "tags": [ - "Query" - ] - } - }, - "/cosmos/distribution/v1beta1/validators/{validator_address}/commission": { - "get": { - "summary": "ValidatorCommission queries accumulated commission for a validator.", - "operationId": "ValidatorCommission", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.distribution.v1beta1.QueryValidatorCommissionResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "validator_address", - "description": "validator_address defines the validator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/distribution/v1beta1/validators/{validator_address}/outstanding_rewards": { - "get": { - "summary": "ValidatorOutstandingRewards queries rewards of a validator address.", - "operationId": "ValidatorOutstandingRewards", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.distribution.v1beta1.QueryValidatorOutstandingRewardsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "validator_address", - "description": "validator_address defines the validator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/distribution/v1beta1/validators/{validator_address}/slashes": { - "get": { - "summary": "ValidatorSlashes queries slash events of a validator.", - "operationId": "ValidatorSlashes", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.distribution.v1beta1.QueryValidatorSlashesResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "validator_address", - "description": "validator_address defines the validator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "starting_height", - "description": "starting_height defines the optional starting height to query the slashes.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "ending_height", - "description": "starting_height defines the optional ending height to query the slashes.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "cosmos.base.query.v1beta1.PageRequest": { - "type": "object", - "properties": { - "key": { - "type": "string", - "format": "byte", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." - }, - "offset": { - "type": "string", - "format": "uint64", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." - }, - "limit": { - "type": "string", - "format": "uint64", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." - }, - "count_total": { - "type": "boolean", - "format": "boolean", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." - } - }, - "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", - "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" - }, - "cosmos.base.query.v1beta1.PageResponse": { - "type": "object", - "properties": { - "next_key": { - "type": "string", - "format": "byte", - "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" - }, - "total": { - "type": "string", - "format": "uint64", - "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" - } - }, - "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" - }, - "cosmos.base.v1beta1.DecCoin": { - "type": "object", - "properties": { - "denom": { - "type": "string" - }, - "amount": { - "type": "string" - } - }, - "description": "DecCoin defines a token with a denomination and a decimal amount.\n\nNOTE: The amount field is an Dec which implements the custom method\nsignatures required by gogoproto." - }, - "cosmos.distribution.v1beta1.DelegationDelegatorReward": { - "type": "object", - "properties": { - "validator_address": { - "type": "string", - "format": "byte" - }, - "reward": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.base.v1beta1.DecCoin" - } - } - }, - "description": "DelegationDelegatorReward defines the properties\nof a delegator's delegation reward." - }, - "cosmos.distribution.v1beta1.Params": { - "type": "object", - "properties": { - "community_tax": { - "type": "string" - }, - "base_proposer_reward": { - "type": "string" - }, - "bonus_proposer_reward": { - "type": "string" - }, - "withdraw_addr_enabled": { - "type": "boolean", - "format": "boolean" - } - }, - "description": "Params defines the set of distribution parameters." - }, - "cosmos.distribution.v1beta1.QueryCommunityPoolResponse": { - "type": "object", - "properties": { - "pool": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.base.v1beta1.DecCoin" - }, - "description": "pool defines community pool's coins." - } - }, - "description": "QueryCommunityPoolResponse is the response type for the Query/CommunityPool RPC method." - }, - "cosmos.distribution.v1beta1.QueryDelegationRewardsResponse": { - "type": "object", - "properties": { - "rewards": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.base.v1beta1.DecCoin" - }, - "description": "rewards defines the rewards accrued by a delegation." - } - }, - "description": "QueryDelegationRewardsResponse is the response type for the Query/DelegationRewards RPC method." - }, - "cosmos.distribution.v1beta1.QueryDelegationTotalRewardsResponse": { - "type": "object", - "properties": { - "rewards": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.distribution.v1beta1.DelegationDelegatorReward" - }, - "description": "rewards defines all the rewards accrued by a delegator." - }, - "total": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.base.v1beta1.DecCoin" - }, - "description": "total defines the sum of all the rewards." - } - }, - "description": "QueryDelegationTotalRewardsResponse is the response type for the Query/DelegationTotalRewards RPC method." - }, - "cosmos.distribution.v1beta1.QueryDelegatorValidatorsResponse": { - "type": "object", - "properties": { - "validators": { - "type": "array", - "items": { - "type": "string", - "format": "byte" - }, - "description": "validators defines the validators a delegator is delegating for." - } - }, - "description": "QueryDelegatorValidatorsResponse is the response type for the Query/DelegatorValidators RPC method." - }, - "cosmos.distribution.v1beta1.QueryDelegatorWithdrawAddressResponse": { - "type": "object", - "properties": { - "withdraw_address": { - "type": "string", - "format": "byte", - "description": "withdraw_address defines the delegator address to query for." - } - }, - "description": "QueryDelegatorWithdrawAddressResponse is the response type for the Query/DelegatorWithdrawAddress RPC method." - }, - "cosmos.distribution.v1beta1.QueryParamsResponse": { - "type": "object", - "properties": { - "params": { - "$ref": "#/definitions/cosmos.distribution.v1beta1.Params", - "description": "params defines the parameters of the module." - } - }, - "description": "QueryParamsResponse is the response type for the Query/Params RPC method." - }, - "cosmos.distribution.v1beta1.QueryValidatorCommissionResponse": { - "type": "object", - "properties": { - "commission": { - "$ref": "#/definitions/cosmos.distribution.v1beta1.ValidatorAccumulatedCommission", - "description": "commission defines the commision the validator received." - } - }, - "title": "QueryValidatorCommissionResponse is the response type for the Query/ValidatorCommission RPC method" - }, - "cosmos.distribution.v1beta1.QueryValidatorOutstandingRewardsResponse": { - "type": "object", - "properties": { - "rewards": { - "$ref": "#/definitions/cosmos.distribution.v1beta1.ValidatorOutstandingRewards" - } - }, - "description": "QueryValidatorOutstandingRewardsResponse is the response type for the Query/ValidatorOutstandingRewards RPC method." - }, - "cosmos.distribution.v1beta1.QueryValidatorSlashesResponse": { - "type": "object", - "properties": { - "slashes": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.distribution.v1beta1.ValidatorSlashEvent" - }, - "description": "slashes defines the slashes the validator received." - }, - "pagination": { - "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryValidatorSlashesResponse is the response type for the Query/ValidatorSlashes RPC method." - }, - "cosmos.distribution.v1beta1.ValidatorAccumulatedCommission": { - "type": "object", - "properties": { - "commission": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.base.v1beta1.DecCoin" - } - } - }, - "title": "accumulated commission for a validator\nkept as a running counter, can be withdrawn at any time" - }, - "cosmos.distribution.v1beta1.ValidatorOutstandingRewards": { - "type": "object", - "properties": { - "rewards": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.base.v1beta1.DecCoin" - } - } - }, - "title": "outstanding (un-withdrawn) rewards for a validator\ninexpensive to track, allows simple sanity checks" - }, - "cosmos.distribution.v1beta1.ValidatorSlashEvent": { - "type": "object", - "properties": { - "validator_period": { - "type": "string", - "format": "uint64" - }, - "fraction": { - "type": "string" - } - }, - "title": "validator slash event\nheight is implicit within the store key\nneeded to calculate appropriate amounts of staking token\nfor delegations which withdraw after a slash has occurred" - }, - "google.protobuf.Any": { - "type": "object", - "properties": { - "type_url": { - "type": "string" - }, - "value": { - "type": "string", - "format": "byte" - } - } - }, - "grpc.gateway.runtime.Error": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/google.protobuf.Any" - } - } - } - } - } -} diff --git a/cosmos/evidence/v1beta1/query.swagger.json b/cosmos/evidence/v1beta1/query.swagger.json deleted file mode 100644 index 1a23078b1aad..000000000000 --- a/cosmos/evidence/v1beta1/query.swagger.json +++ /dev/null @@ -1,214 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "cosmos/evidence/v1beta1/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/cosmos/evidence/v1beta1/evidence": { - "get": { - "summary": "AllEvidence queries all evidence.", - "operationId": "AllEvidence", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.evidence.v1beta1.QueryAllEvidenceResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/evidence/v1beta1/evidence/{evidence_hash}": { - "get": { - "summary": "Evidence queries evidence based on evidence hash.", - "operationId": "Evidence", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.evidence.v1beta1.QueryEvidenceResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "evidence_hash", - "description": "evidence_hash defines the hash of the requested evidence.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "cosmos.base.query.v1beta1.PageRequest": { - "type": "object", - "properties": { - "key": { - "type": "string", - "format": "byte", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." - }, - "offset": { - "type": "string", - "format": "uint64", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." - }, - "limit": { - "type": "string", - "format": "uint64", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." - }, - "count_total": { - "type": "boolean", - "format": "boolean", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." - } - }, - "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", - "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" - }, - "cosmos.base.query.v1beta1.PageResponse": { - "type": "object", - "properties": { - "next_key": { - "type": "string", - "format": "byte", - "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" - }, - "total": { - "type": "string", - "format": "uint64", - "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" - } - }, - "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" - }, - "cosmos.evidence.v1beta1.QueryAllEvidenceResponse": { - "type": "object", - "properties": { - "evidence": { - "type": "array", - "items": { - "$ref": "#/definitions/google.protobuf.Any" - }, - "description": "evidence returns all evidences." - }, - "pagination": { - "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryAllEvidenceResponse is the response type for the Query/AllEvidence RPC method." - }, - "cosmos.evidence.v1beta1.QueryEvidenceResponse": { - "type": "object", - "properties": { - "evidence": { - "$ref": "#/definitions/google.protobuf.Any", - "description": "evidence returns the requested evidence." - } - }, - "description": "QueryEvidenceResponse is the response type for the Query/Evidence RPC method." - }, - "google.protobuf.Any": { - "type": "object", - "properties": { - "type_url": { - "type": "string", - "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." - }, - "value": { - "type": "string", - "format": "byte", - "description": "Must be a valid serialized protocol buffer of the above specified type." - } - }, - "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := \u0026pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" - }, - "grpc.gateway.runtime.Error": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/google.protobuf.Any" - } - } - } - } - } -} diff --git a/cosmos/gov/v1beta1/query.swagger.json b/cosmos/gov/v1beta1/query.swagger.json deleted file mode 100644 index dc560b8ab4e0..000000000000 --- a/cosmos/gov/v1beta1/query.swagger.json +++ /dev/null @@ -1,785 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "cosmos/gov/v1beta1/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/cosmos/gov/v1beta1/params/{params_type}": { - "get": { - "summary": "Params queries all parameters of the gov module.", - "operationId": "Params", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.gov.v1beta1.QueryParamsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "params_type", - "description": "params_type defines which parameters to query for, can be one of \"voting\", \"tallying\" or \"deposit\".", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/gov/v1beta1/proposals": { - "get": { - "summary": "Proposals queries all proposals based on given status.", - "operationId": "Proposals", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.gov.v1beta1.QueryProposalsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "proposal_status", - "description": "proposal_status defines the status of the proposals.\n\n - PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed.", - "in": "query", - "required": false, - "type": "string", - "enum": [ - "PROPOSAL_STATUS_UNSPECIFIED", - "PROPOSAL_STATUS_DEPOSIT_PERIOD", - "PROPOSAL_STATUS_VOTING_PERIOD", - "PROPOSAL_STATUS_PASSED", - "PROPOSAL_STATUS_REJECTED", - "PROPOSAL_STATUS_FAILED" - ], - "default": "PROPOSAL_STATUS_UNSPECIFIED" - }, - { - "name": "voter", - "description": "voter defines the voter address for the proposals.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "depositor", - "description": "depositor defines the deposit addresses from the proposals.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/gov/v1beta1/proposals/{proposal_id}": { - "get": { - "summary": "Proposal queries proposal details based on ProposalID.", - "operationId": "Proposal", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.gov.v1beta1.QueryProposalResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "proposal_id", - "description": "proposal_id defines the unique id of the proposal.", - "in": "path", - "required": true, - "type": "string", - "format": "uint64" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/gov/v1beta1/proposals/{proposal_id}/deposits": { - "get": { - "summary": "Deposits queries all deposits of a single proposal.", - "operationId": "Deposits", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.gov.v1beta1.QueryDepositsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "proposal_id", - "description": "proposal_id defines the unique id of the proposal.", - "in": "path", - "required": true, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/gov/v1beta1/proposals/{proposal_id}/deposits/{depositor}": { - "get": { - "summary": "Deposit queries single deposit information based proposalID, depositAddr.", - "operationId": "Deposit", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.gov.v1beta1.QueryDepositResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "proposal_id", - "description": "proposal_id defines the unique id of the proposal.", - "in": "path", - "required": true, - "type": "string", - "format": "uint64" - }, - { - "name": "depositor", - "description": "depositor defines the deposit addresses from the proposals.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/gov/v1beta1/proposals/{proposal_id}/tally": { - "get": { - "summary": "TallyResult queries the tally of a proposal vote.", - "operationId": "TallyResult", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.gov.v1beta1.QueryTallyResultResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "proposal_id", - "description": "proposal_id defines the unique id of the proposal.", - "in": "path", - "required": true, - "type": "string", - "format": "uint64" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/gov/v1beta1/proposals/{proposal_id}/votes": { - "get": { - "summary": "Votes queries votes of a given proposal.", - "operationId": "Votes", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.gov.v1beta1.QueryVotesResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "proposal_id", - "description": "proposal_id defines the unique id of the proposal.", - "in": "path", - "required": true, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/gov/v1beta1/proposals/{proposal_id}/votes/{voter}": { - "get": { - "summary": "Vote queries voted information based on proposalID, voterAddr.", - "operationId": "Vote", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.gov.v1beta1.QueryVoteResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "proposal_id", - "description": "proposal_id defines the unique id of the proposal.", - "in": "path", - "required": true, - "type": "string", - "format": "uint64" - }, - { - "name": "voter", - "description": "voter defines the oter address for the proposals.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "cosmos.base.query.v1beta1.PageRequest": { - "type": "object", - "properties": { - "key": { - "type": "string", - "format": "byte", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." - }, - "offset": { - "type": "string", - "format": "uint64", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." - }, - "limit": { - "type": "string", - "format": "uint64", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." - }, - "count_total": { - "type": "boolean", - "format": "boolean", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." - } - }, - "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", - "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" - }, - "cosmos.base.query.v1beta1.PageResponse": { - "type": "object", - "properties": { - "next_key": { - "type": "string", - "format": "byte", - "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" - }, - "total": { - "type": "string", - "format": "uint64", - "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" - } - }, - "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" - }, - "cosmos.base.v1beta1.Coin": { - "type": "object", - "properties": { - "denom": { - "type": "string" - }, - "amount": { - "type": "string" - } - }, - "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." - }, - "cosmos.gov.v1beta1.Deposit": { - "type": "object", - "properties": { - "proposal_id": { - "type": "string", - "format": "uint64" - }, - "depositor": { - "type": "string", - "format": "byte" - }, - "amount": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.base.v1beta1.Coin" - } - } - }, - "title": "Deposit defines an amount deposited by an account address to an active proposal" - }, - "cosmos.gov.v1beta1.DepositParams": { - "type": "object", - "properties": { - "min_deposit": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.base.v1beta1.Coin" - }, - "description": "Minimum deposit for a proposal to enter voting period." - }, - "max_deposit_period": { - "type": "string", - "description": "Maximum period for Atom holders to deposit on a proposal. Initial value: 2 months." - } - }, - "title": "DepositParams defines the params around deposits for governance" - }, - "cosmos.gov.v1beta1.Proposal": { - "type": "object", - "properties": { - "proposal_id": { - "type": "string", - "format": "uint64" - }, - "content": { - "$ref": "#/definitions/google.protobuf.Any" - }, - "status": { - "$ref": "#/definitions/cosmos.gov.v1beta1.ProposalStatus" - }, - "final_tally_result": { - "$ref": "#/definitions/cosmos.gov.v1beta1.TallyResult" - }, - "submit_time": { - "type": "string", - "format": "date-time" - }, - "deposit_end_time": { - "type": "string", - "format": "date-time" - }, - "total_deposit": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.base.v1beta1.Coin" - } - }, - "voting_start_time": { - "type": "string", - "format": "date-time" - }, - "voting_end_time": { - "type": "string", - "format": "date-time" - } - }, - "title": "Proposal defines the core field members of a governance proposal" - }, - "cosmos.gov.v1beta1.ProposalStatus": { - "type": "string", - "enum": [ - "PROPOSAL_STATUS_UNSPECIFIED", - "PROPOSAL_STATUS_DEPOSIT_PERIOD", - "PROPOSAL_STATUS_VOTING_PERIOD", - "PROPOSAL_STATUS_PASSED", - "PROPOSAL_STATUS_REJECTED", - "PROPOSAL_STATUS_FAILED" - ], - "default": "PROPOSAL_STATUS_UNSPECIFIED", - "description": "- PROPOSAL_STATUS_UNSPECIFIED: PROPOSAL_STATUS_UNSPECIFIED defines the default propopsal status.\n - PROPOSAL_STATUS_DEPOSIT_PERIOD: PROPOSAL_STATUS_DEPOSIT_PERIOD defines a proposal status during the deposit period.\n - PROPOSAL_STATUS_VOTING_PERIOD: PROPOSAL_STATUS_VOTING_PERIOD defines a proposal status during the voting period.\n - PROPOSAL_STATUS_PASSED: PROPOSAL_STATUS_PASSED defines a proposal status of a proposal that has passed.\n - PROPOSAL_STATUS_REJECTED: PROPOSAL_STATUS_REJECTED defines a proposal status of a proposal that has been rejected.\n - PROPOSAL_STATUS_FAILED: PROPOSAL_STATUS_FAILED defines a proposal status of a proposal that has failed.", - "title": "ProposalStatus is a type alias that represents a proposal status as a byte" - }, - "cosmos.gov.v1beta1.QueryDepositResponse": { - "type": "object", - "properties": { - "deposit": { - "$ref": "#/definitions/cosmos.gov.v1beta1.Deposit", - "description": "deposit defines the requested deposit." - } - }, - "description": "QueryDepositResponse is the response type for the Query/Deposit RPC method." - }, - "cosmos.gov.v1beta1.QueryDepositsResponse": { - "type": "object", - "properties": { - "deposits": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.gov.v1beta1.Deposit" - } - }, - "pagination": { - "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryDepositsResponse is the response type for the Query/Deposits RPC method." - }, - "cosmos.gov.v1beta1.QueryParamsResponse": { - "type": "object", - "properties": { - "voting_params": { - "$ref": "#/definitions/cosmos.gov.v1beta1.VotingParams", - "description": "voting_params defines the parameters related to voting." - }, - "deposit_params": { - "$ref": "#/definitions/cosmos.gov.v1beta1.DepositParams", - "description": "deposit_params defines the parameters related to deposit." - }, - "tally_params": { - "$ref": "#/definitions/cosmos.gov.v1beta1.TallyParams", - "description": "tally_params defines the parameters related to tally." - } - }, - "description": "QueryParamsResponse is the response type for the Query/Params RPC method." - }, - "cosmos.gov.v1beta1.QueryProposalResponse": { - "type": "object", - "properties": { - "proposal": { - "$ref": "#/definitions/cosmos.gov.v1beta1.Proposal" - } - }, - "description": "QueryProposalResponse is the response type for the Query/Proposal RPC method." - }, - "cosmos.gov.v1beta1.QueryProposalsResponse": { - "type": "object", - "properties": { - "proposals": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.gov.v1beta1.Proposal" - } - }, - "pagination": { - "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryProposalsResponse is the response type for the Query/Proposals RPC method." - }, - "cosmos.gov.v1beta1.QueryTallyResultResponse": { - "type": "object", - "properties": { - "tally": { - "$ref": "#/definitions/cosmos.gov.v1beta1.TallyResult", - "description": "tally defines the requested tally." - } - }, - "description": "QueryTallyResultResponse is the response type for the Query/Tally RPC method." - }, - "cosmos.gov.v1beta1.QueryVoteResponse": { - "type": "object", - "properties": { - "vote": { - "$ref": "#/definitions/cosmos.gov.v1beta1.Vote", - "description": "vote defined the queried vote." - } - }, - "description": "QueryVoteResponse is the response type for the Query/Vote RPC method." - }, - "cosmos.gov.v1beta1.QueryVotesResponse": { - "type": "object", - "properties": { - "votes": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.gov.v1beta1.Vote" - }, - "description": "votes defined the queried votes." - }, - "pagination": { - "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryVotesResponse is the response type for the Query/Votes RPC method." - }, - "cosmos.gov.v1beta1.TallyParams": { - "type": "object", - "properties": { - "quorum": { - "type": "string", - "format": "byte", - "description": "Minimum percentage of total stake needed to vote for a result to be considered valid." - }, - "threshold": { - "type": "string", - "format": "byte", - "description": "Minimum proportion of Yes votes for proposal to pass. Initial value: 0.5." - }, - "veto": { - "type": "string", - "format": "byte", - "description": "Minimum value of Veto votes to Total votes ratio for proposal to be vetoed. Initial value: 1/3." - } - }, - "title": "TallyParams defines the params around Tallying votes in governance" - }, - "cosmos.gov.v1beta1.TallyResult": { - "type": "object", - "properties": { - "yes": { - "type": "string" - }, - "abstain": { - "type": "string" - }, - "no": { - "type": "string" - }, - "no_with_veto": { - "type": "string" - } - }, - "title": "TallyResult defines a standard tally for a proposal" - }, - "cosmos.gov.v1beta1.Vote": { - "type": "object", - "properties": { - "proposal_id": { - "type": "string", - "format": "uint64" - }, - "voter": { - "type": "string", - "format": "byte" - }, - "option": { - "$ref": "#/definitions/cosmos.gov.v1beta1.VoteOption" - } - }, - "description": "Vote defines a vote on a governance proposal. A vote corresponds to a proposal\nID, the voter, and the vote option." - }, - "cosmos.gov.v1beta1.VoteOption": { - "type": "string", - "enum": [ - "VOTE_OPTION_UNSPECIFIED", - "VOTE_OPTION_YES", - "VOTE_OPTION_ABSTAIN", - "VOTE_OPTION_NO", - "VOTE_OPTION_NO_WITH_VETO" - ], - "default": "VOTE_OPTION_UNSPECIFIED", - "description": "- VOTE_OPTION_UNSPECIFIED: VOTE_OPTION_UNSPECIFIED defines a no-op vote option.\n - VOTE_OPTION_YES: VOTE_OPTION_YES defines a yes vote option.\n - VOTE_OPTION_ABSTAIN: VOTE_OPTION_ABSTAIN defines an abstain vote option.\n - VOTE_OPTION_NO: VOTE_OPTION_NO defines a no vote option.\n - VOTE_OPTION_NO_WITH_VETO: VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option.", - "title": "VoteOption defines a vote option" - }, - "cosmos.gov.v1beta1.VotingParams": { - "type": "object", - "properties": { - "voting_period": { - "type": "string", - "description": "Length of the voting period." - } - }, - "title": "VotingParams defines the params around Voting in governance" - }, - "google.protobuf.Any": { - "type": "object", - "properties": { - "type_url": { - "type": "string", - "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." - }, - "value": { - "type": "string", - "format": "byte", - "description": "Must be a valid serialized protocol buffer of the above specified type." - } - }, - "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := \u0026pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" - }, - "grpc.gateway.runtime.Error": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/google.protobuf.Any" - } - } - } - } - } -} diff --git a/cosmos/mint/v1beta1/query.swagger.json b/cosmos/mint/v1beta1/query.swagger.json deleted file mode 100644 index ccaafc8931d2..000000000000 --- a/cosmos/mint/v1beta1/query.swagger.json +++ /dev/null @@ -1,182 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "cosmos/mint/v1beta1/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/cosmos/mint/v1beta1/annual_provisions": { - "get": { - "summary": "AnnualProvisions current minting annual provisions value.", - "operationId": "AnnualProvisions", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.mint.v1beta1.QueryAnnualProvisionsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "tags": [ - "Query" - ] - } - }, - "/cosmos/mint/v1beta1/inflation": { - "get": { - "summary": "Inflation returns the current minting inflation value.", - "operationId": "Inflation", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.mint.v1beta1.QueryInflationResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "tags": [ - "Query" - ] - } - }, - "/cosmos/mint/v1beta1/params": { - "get": { - "summary": "Params returns the total set of minting parameters.", - "operationId": "Params", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.mint.v1beta1.QueryParamsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "cosmos.mint.v1beta1.Params": { - "type": "object", - "properties": { - "mint_denom": { - "type": "string", - "title": "type of coin to mint" - }, - "inflation_rate_change": { - "type": "string", - "title": "maximum annual change in inflation rate" - }, - "inflation_max": { - "type": "string", - "title": "maximum inflation rate" - }, - "inflation_min": { - "type": "string", - "title": "minimum inflation rate" - }, - "goal_bonded": { - "type": "string", - "title": "goal of percent bonded atoms" - }, - "blocks_per_year": { - "type": "string", - "format": "uint64", - "title": "expected blocks per year" - } - }, - "title": "mint parameters" - }, - "cosmos.mint.v1beta1.QueryAnnualProvisionsResponse": { - "type": "object", - "properties": { - "annual_provisions": { - "type": "string", - "format": "byte", - "description": "annual_provisions is the current minting annual provisions value." - } - }, - "description": "QueryAnnualProvisionsResponse is the response type for the Query/AnnualProvisions RPC method." - }, - "cosmos.mint.v1beta1.QueryInflationResponse": { - "type": "object", - "properties": { - "inflation": { - "type": "string", - "format": "byte", - "description": "inflation is the current minting inflation value." - } - }, - "description": "QueryInflationResponse is the response type for the Query/Inflation RPC method." - }, - "cosmos.mint.v1beta1.QueryParamsResponse": { - "type": "object", - "properties": { - "params": { - "$ref": "#/definitions/cosmos.mint.v1beta1.Params", - "description": "params defines the parameters of the module." - } - }, - "description": "QueryParamsResponse is the response type for the Query/Params RPC method." - }, - "google.protobuf.Any": { - "type": "object", - "properties": { - "type_url": { - "type": "string" - }, - "value": { - "type": "string", - "format": "byte" - } - } - }, - "grpc.gateway.runtime.Error": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/google.protobuf.Any" - } - } - } - } - } -} diff --git a/cosmos/params/v1beta1/query.swagger.json b/cosmos/params/v1beta1/query.swagger.json deleted file mode 100644 index 6d2444ad07d1..000000000000 --- a/cosmos/params/v1beta1/query.swagger.json +++ /dev/null @@ -1,114 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "cosmos/params/v1beta1/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/cosmos/params/v1beta1/params": { - "get": { - "summary": "Params queries a specific parameter of a module, given its subspace and key.", - "operationId": "Params", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.params.v1beta1.QueryParamsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "subspace", - "description": "subspace defines the module to query the parameter for.", - "in": "query", - "required": false, - "type": "string" - }, - { - "name": "key", - "description": "key defines the key of the parameter in the subspace.", - "in": "query", - "required": false, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "cosmos.params.v1beta1.ParamChange": { - "type": "object", - "properties": { - "subspace": { - "type": "string" - }, - "key": { - "type": "string" - }, - "value": { - "type": "string" - } - }, - "description": "ParamChange defines a parameter change." - }, - "cosmos.params.v1beta1.QueryParamsResponse": { - "type": "object", - "properties": { - "param": { - "$ref": "#/definitions/cosmos.params.v1beta1.ParamChange", - "description": "param defines the queried parameter." - } - }, - "description": "QueryParamsResponse is response type for the Query/Params RPC method." - }, - "google.protobuf.Any": { - "type": "object", - "properties": { - "type_url": { - "type": "string" - }, - "value": { - "type": "string", - "format": "byte" - } - } - }, - "grpc.gateway.runtime.Error": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/google.protobuf.Any" - } - } - } - } - } -} diff --git a/cosmos/slashing/v1beta1/query.swagger.json b/cosmos/slashing/v1beta1/query.swagger.json deleted file mode 100644 index d3e0c9dd9239..000000000000 --- a/cosmos/slashing/v1beta1/query.swagger.json +++ /dev/null @@ -1,302 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "cosmos/slashing/v1beta1/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/cosmos/slashing/v1beta1/params": { - "get": { - "summary": "Params queries the parameters of slashing module", - "operationId": "Params", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.slashing.v1beta1.QueryParamsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "tags": [ - "Query" - ] - } - }, - "/cosmos/slashing/v1beta1/signing_infos": { - "get": { - "summary": "SigningInfos queries signing info of all validators", - "operationId": "SigningInfos", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.slashing.v1beta1.QuerySigningInfosResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/slashing/v1beta1/signing_infos/{cons_address}": { - "get": { - "summary": "SigningInfo queries the signing info of given cons address", - "operationId": "SigningInfo", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.slashing.v1beta1.QuerySigningInfoResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "cons_address", - "description": "cons_address is the address to query signing info of", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "cosmos.base.query.v1beta1.PageRequest": { - "type": "object", - "properties": { - "key": { - "type": "string", - "format": "byte", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." - }, - "offset": { - "type": "string", - "format": "uint64", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." - }, - "limit": { - "type": "string", - "format": "uint64", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." - }, - "count_total": { - "type": "boolean", - "format": "boolean", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." - } - }, - "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", - "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" - }, - "cosmos.base.query.v1beta1.PageResponse": { - "type": "object", - "properties": { - "next_key": { - "type": "string", - "format": "byte", - "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" - }, - "total": { - "type": "string", - "format": "uint64", - "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" - } - }, - "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" - }, - "cosmos.slashing.v1beta1.Params": { - "type": "object", - "properties": { - "signed_blocks_window": { - "type": "string", - "format": "int64" - }, - "min_signed_per_window": { - "type": "string", - "format": "byte" - }, - "downtime_jail_duration": { - "type": "string" - }, - "slash_fraction_double_sign": { - "type": "string", - "format": "byte" - }, - "slash_fraction_downtime": { - "type": "string", - "format": "byte" - } - }, - "title": "Params - used for initializing default parameter for slashing at genesis" - }, - "cosmos.slashing.v1beta1.QueryParamsResponse": { - "type": "object", - "properties": { - "params": { - "$ref": "#/definitions/cosmos.slashing.v1beta1.Params" - } - }, - "title": "QueryParamsResponse is the response type for the Query/Params RPC method" - }, - "cosmos.slashing.v1beta1.QuerySigningInfoResponse": { - "type": "object", - "properties": { - "val_signing_info": { - "$ref": "#/definitions/cosmos.slashing.v1beta1.ValidatorSigningInfo", - "title": "val_signing_info is the signing info of requested val cons address" - } - }, - "title": "QuerySigningInfoResponse is the response type for the Query/SigningInfo RPC method" - }, - "cosmos.slashing.v1beta1.QuerySigningInfosResponse": { - "type": "object", - "properties": { - "info": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.slashing.v1beta1.ValidatorSigningInfo" - }, - "title": "info is the signing info of all validators" - }, - "pagination": { - "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse" - } - }, - "title": "QuerySigningInfosResponse is the response type for the Query/SigningInfos RPC method" - }, - "cosmos.slashing.v1beta1.ValidatorSigningInfo": { - "type": "object", - "properties": { - "address": { - "type": "string", - "format": "byte" - }, - "start_height": { - "type": "string", - "format": "int64", - "title": "height at which validator was first a candidate OR was unjailed" - }, - "index_offset": { - "type": "string", - "format": "int64", - "title": "index offset into signed block bit array" - }, - "jailed_until": { - "type": "string", - "format": "date-time", - "title": "timestamp validator cannot be unjailed until" - }, - "tombstoned": { - "type": "boolean", - "format": "boolean", - "title": "whether or not a validator has been tombstoned (killed out of validator set)" - }, - "missed_blocks_counter": { - "type": "string", - "format": "int64", - "title": "missed blocks counter (to avoid scanning the array every time)" - } - }, - "title": "ValidatorSigningInfo defines the signing info for a validator" - }, - "google.protobuf.Any": { - "type": "object", - "properties": { - "type_url": { - "type": "string" - }, - "value": { - "type": "string", - "format": "byte" - } - } - }, - "grpc.gateway.runtime.Error": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/google.protobuf.Any" - } - } - } - } - } -} diff --git a/cosmos/staking/v1beta1/query.swagger.json b/cosmos/staking/v1beta1/query.swagger.json deleted file mode 100644 index b34a1bc9b5df..000000000000 --- a/cosmos/staking/v1beta1/query.swagger.json +++ /dev/null @@ -1,1385 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "cosmos/staking/v1beta1/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/cosmos/staking/v1beta1/delegations/{delegator_addr}": { - "get": { - "summary": "DelegatorDelegations queries all delegations of a given delegator address.", - "operationId": "DelegatorDelegations", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "delegator_addr", - "description": "delegator_addr defines the delegator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/delegators/{delegator_addr}/redelegations": { - "get": { - "summary": "Redelegations queries redelegations of given address.", - "operationId": "Redelegations", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.staking.v1beta1.QueryRedelegationsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "delegator_addr", - "description": "delegator_addr defines the delegator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "src_validator_addr", - "description": "src_validator_addr defines the validator address to redelegate from.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "dst_validator_addr", - "description": "dst_validator_addr defines the validator address to redelegate to.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/delegators/{delegator_addr}/unbonding_delegations": { - "get": { - "summary": "DelegatorUnbondingDelegations queries all unbonding delegations of a given delegator address.", - "operationId": "DelegatorUnbondingDelegations", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "delegator_addr", - "description": "delegator_addr defines the delegator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators": { - "get": { - "summary": "DelegatorValidators queries all validators info for given delegator address.", - "operationId": "DelegatorValidators", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "delegator_addr", - "description": "delegator_addr defines the delegator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/delegators/{delegator_addr}/validators/{validator_addr}": { - "get": { - "summary": "DelegatorValidator queries validator info for given delegator validator pair.", - "operationId": "DelegatorValidator", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.staking.v1beta1.QueryDelegatorValidatorResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "delegator_addr", - "description": "delegator_addr defines the delegator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "validator_addr", - "description": "validator_addr defines the validator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/historical_info/{height}": { - "get": { - "summary": "HistoricalInfo queries the historical info for given height.", - "operationId": "HistoricalInfo", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.staking.v1beta1.QueryHistoricalInfoResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "height", - "description": "height defines at which height to query the historical info.", - "in": "path", - "required": true, - "type": "string", - "format": "int64" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/params": { - "get": { - "summary": "Parameters queries the staking parameters.", - "operationId": "Params", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.staking.v1beta1.QueryParamsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/pool": { - "get": { - "summary": "Pool queries the pool info.", - "operationId": "Pool", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.staking.v1beta1.QueryPoolResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/validators": { - "get": { - "summary": "Validators queries all validators that match the given status.", - "operationId": "Validators", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.staking.v1beta1.QueryValidatorsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "status", - "description": "status enables to query for validators matching a given status.", - "in": "query", - "required": false, - "type": "string" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/validators/{validator_addr}": { - "get": { - "summary": "Validator queries validator info for given validator address.", - "operationId": "Validator", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.staking.v1beta1.QueryValidatorResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "validator_addr", - "description": "validator_addr defines the validator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/validators/{validator_addr}/delegations": { - "get": { - "summary": "ValidatorDelegations queries delegate info for given validator.", - "operationId": "ValidatorDelegations", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.staking.v1beta1.QueryValidatorDelegationsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "validator_addr", - "description": "validator_addr defines the validator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}": { - "get": { - "summary": "Delegation queries delegate info for given validator delegator pair.", - "operationId": "Delegation", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.staking.v1beta1.QueryDelegationResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "validator_addr", - "description": "validator_addr defines the validator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "delegator_addr", - "description": "delegator_addr defines the delegator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/validators/{validator_addr}/delegations/{delegator_addr}/unbonding_delegation": { - "get": { - "summary": "UnbondingDelegation queries unbonding info for given validator delegator pair.", - "operationId": "UnbondingDelegation", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.staking.v1beta1.QueryUnbondingDelegationResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "validator_addr", - "description": "validator_addr defines the validator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "delegator_addr", - "description": "delegator_addr defines the delegator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/staking/v1beta1/validators/{validator_addr}/unbonding_delegations": { - "get": { - "summary": "ValidatorUnbondingDelegations queries unbonding delegations of a validator.", - "operationId": "ValidatorUnbondingDelegations", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "validator_addr", - "description": "validator_addr defines the validator address to query for.", - "in": "path", - "required": true, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "cosmos.base.query.v1beta1.PageRequest": { - "type": "object", - "properties": { - "key": { - "type": "string", - "format": "byte", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." - }, - "offset": { - "type": "string", - "format": "uint64", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." - }, - "limit": { - "type": "string", - "format": "uint64", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." - }, - "count_total": { - "type": "boolean", - "format": "boolean", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." - } - }, - "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", - "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" - }, - "cosmos.base.query.v1beta1.PageResponse": { - "type": "object", - "properties": { - "next_key": { - "type": "string", - "format": "byte", - "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" - }, - "total": { - "type": "string", - "format": "uint64", - "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" - } - }, - "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" - }, - "cosmos.base.v1beta1.Coin": { - "type": "object", - "properties": { - "denom": { - "type": "string" - }, - "amount": { - "type": "string" - } - }, - "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." - }, - "cosmos.staking.v1beta1.Commission": { - "type": "object", - "properties": { - "commission_rates": { - "$ref": "#/definitions/cosmos.staking.v1beta1.CommissionRates" - }, - "update_time": { - "type": "string", - "format": "date-time" - } - }, - "description": "Commission defines a commission parameters for a given validator." - }, - "cosmos.staking.v1beta1.CommissionRates": { - "type": "object", - "properties": { - "rate": { - "type": "string" - }, - "max_rate": { - "type": "string" - }, - "max_change_rate": { - "type": "string" - } - }, - "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." - }, - "cosmos.staking.v1beta1.Delegation": { - "type": "object", - "properties": { - "delegator_address": { - "type": "string", - "format": "byte" - }, - "validator_address": { - "type": "string", - "format": "byte" - }, - "shares": { - "type": "string" - } - }, - "description": "Delegation represents the bond with tokens held by an account. It is\nowned by one delegator, and is associated with the voting power of one\nvalidator." - }, - "cosmos.staking.v1beta1.DelegationResponse": { - "type": "object", - "properties": { - "delegation": { - "$ref": "#/definitions/cosmos.staking.v1beta1.Delegation" - }, - "balance": { - "$ref": "#/definitions/cosmos.base.v1beta1.Coin" - } - }, - "description": "DelegationResponse is equivalent to Delegation except that it contains a balance\nin addition to shares which is more suitable for client responses." - }, - "cosmos.staking.v1beta1.Description": { - "type": "object", - "properties": { - "moniker": { - "type": "string" - }, - "identity": { - "type": "string" - }, - "website": { - "type": "string" - }, - "security_contact": { - "type": "string" - }, - "details": { - "type": "string" - } - }, - "description": "Description defines a validator description." - }, - "cosmos.staking.v1beta1.HistoricalInfo": { - "type": "object", - "properties": { - "header": { - "$ref": "#/definitions/tendermint.types.Header" - }, - "valset": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.staking.v1beta1.Validator" - } - } - }, - "description": "HistoricalInfo contains the historical information that gets stored at\neach height." - }, - "cosmos.staking.v1beta1.Params": { - "type": "object", - "properties": { - "unbonding_time": { - "type": "string" - }, - "max_validators": { - "type": "integer", - "format": "int64" - }, - "max_entries": { - "type": "integer", - "format": "int64" - }, - "historical_entries": { - "type": "integer", - "format": "int64" - }, - "bond_denom": { - "type": "string" - } - }, - "description": "Params defines the parameters for the staking module." - }, - "cosmos.staking.v1beta1.Pool": { - "type": "object", - "properties": { - "not_bonded_tokens": { - "type": "string" - }, - "bonded_tokens": { - "type": "string" - } - }, - "title": "Pool - tracking bonded and not-bonded token supply of the bond denomination" - }, - "cosmos.staking.v1beta1.QueryDelegationResponse": { - "type": "object", - "properties": { - "delegation_response": { - "$ref": "#/definitions/cosmos.staking.v1beta1.DelegationResponse", - "description": "delegation_responses defines the delegation info of a delegation." - } - }, - "description": "QueryDelegationResponse is response type for the Query/Delegation RPC method." - }, - "cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse": { - "type": "object", - "properties": { - "delegation_responses": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.staking.v1beta1.DelegationResponse" - }, - "description": "delegation_responses defines all the delegations' info of a delegator." - }, - "pagination": { - "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryDelegatorDelegationsResponse is response type for the Query/DelegatorDelegations RPC method." - }, - "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse": { - "type": "object", - "properties": { - "unbonding_responses": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.staking.v1beta1.UnbondingDelegation" - } - }, - "pagination": { - "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryUnbondingDelegatorDelegationsResponse is response type for the Query/UnbondingDelegatorDelegations RPC method." - }, - "cosmos.staking.v1beta1.QueryDelegatorValidatorResponse": { - "type": "object", - "properties": { - "validator": { - "$ref": "#/definitions/cosmos.staking.v1beta1.Validator", - "description": "validator defines the the validator info." - } - }, - "description": "QueryDelegatorValidatorResponse response type for the Query/DelegatorValidator RPC method." - }, - "cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse": { - "type": "object", - "properties": { - "validators": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.staking.v1beta1.Validator" - }, - "description": "validators defines the the validators' info of a delegator." - }, - "pagination": { - "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryDelegatorValidatorsResponse is response type for the Query/DelegatorValidators RPC method." - }, - "cosmos.staking.v1beta1.QueryHistoricalInfoResponse": { - "type": "object", - "properties": { - "hist": { - "$ref": "#/definitions/cosmos.staking.v1beta1.HistoricalInfo", - "description": "hist defines the historical info at the given height." - } - }, - "description": "QueryHistoricalInfoResponse is response type for the Query/HistoricalInfo RPC method." - }, - "cosmos.staking.v1beta1.QueryParamsResponse": { - "type": "object", - "properties": { - "params": { - "$ref": "#/definitions/cosmos.staking.v1beta1.Params", - "description": "params holds all the parameters of this module." - } - }, - "description": "QueryParamsResponse is response type for the Query/Params RPC method." - }, - "cosmos.staking.v1beta1.QueryPoolResponse": { - "type": "object", - "properties": { - "pool": { - "$ref": "#/definitions/cosmos.staking.v1beta1.Pool", - "description": "pool defines the pool info." - } - }, - "description": "QueryPoolResponse is response type for the Query/Pool RPC method." - }, - "cosmos.staking.v1beta1.QueryRedelegationsResponse": { - "type": "object", - "properties": { - "redelegation_responses": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.staking.v1beta1.RedelegationResponse" - } - }, - "pagination": { - "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryRedelegationsResponse is response type for the Query/Redelegations RPC method." - }, - "cosmos.staking.v1beta1.QueryUnbondingDelegationResponse": { - "type": "object", - "properties": { - "unbond": { - "$ref": "#/definitions/cosmos.staking.v1beta1.UnbondingDelegation", - "description": "unbond defines the unbonding information of a delegation." - } - }, - "description": "QueryDelegationResponse is response type for the Query/UnbondingDelegation RPC method." - }, - "cosmos.staking.v1beta1.QueryValidatorDelegationsResponse": { - "type": "object", - "properties": { - "delegation_responses": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.staking.v1beta1.DelegationResponse" - } - }, - "pagination": { - "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "title": "QueryValidatorDelegationsResponse is response type for the Query/ValidatorDelegations RPC method" - }, - "cosmos.staking.v1beta1.QueryValidatorResponse": { - "type": "object", - "properties": { - "validator": { - "$ref": "#/definitions/cosmos.staking.v1beta1.Validator", - "description": "validator defines the the validator info." - } - }, - "title": "QueryValidatorResponse is response type for the Query/Validator RPC method" - }, - "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse": { - "type": "object", - "properties": { - "unbonding_responses": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.staking.v1beta1.UnbondingDelegation" - } - }, - "pagination": { - "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryValidatorUnbondingDelegationsResponse is response type for the Query/ValidatorUnbondingDelegations RPC method." - }, - "cosmos.staking.v1beta1.QueryValidatorsResponse": { - "type": "object", - "properties": { - "validators": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.staking.v1beta1.Validator" - }, - "description": "validators contains all the queried validators." - }, - "pagination": { - "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "title": "QueryValidatorsResponse is response type for the Query/Validators RPC method" - }, - "cosmos.staking.v1beta1.Redelegation": { - "type": "object", - "properties": { - "delegator_address": { - "type": "string", - "format": "byte" - }, - "validator_src_address": { - "type": "string", - "format": "byte" - }, - "validator_dst_address": { - "type": "string", - "format": "byte" - }, - "entries": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.staking.v1beta1.RedelegationEntry" - } - } - }, - "description": "Redelegation contains the list of a particular delegator's redelegating bonds\nfrom a particular source validator to a particular destination validator." - }, - "cosmos.staking.v1beta1.RedelegationEntry": { - "type": "object", - "properties": { - "creation_height": { - "type": "string", - "format": "int64" - }, - "completion_time": { - "type": "string", - "format": "date-time" - }, - "initial_balance": { - "type": "string" - }, - "shares_dst": { - "type": "string" - } - }, - "description": "RedelegationEntry defines a redelegation object with relevant metadata." - }, - "cosmos.staking.v1beta1.RedelegationEntryResponse": { - "type": "object", - "properties": { - "redelegation_entry": { - "$ref": "#/definitions/cosmos.staking.v1beta1.RedelegationEntry" - }, - "balance": { - "type": "string" - } - }, - "description": "RedelegationEntryResponse is equivalent to a RedelegationEntry except that it\ncontains a balance in addition to shares which is more suitable for client\nresponses." - }, - "cosmos.staking.v1beta1.RedelegationResponse": { - "type": "object", - "properties": { - "redelegation": { - "$ref": "#/definitions/cosmos.staking.v1beta1.Redelegation" - }, - "entries": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.staking.v1beta1.RedelegationEntryResponse" - } - } - }, - "description": "RedelegationResponse is equivalent to a Redelegation except that its entries\ncontain a balance in addition to shares which is more suitable for client\nresponses." - }, - "cosmos.staking.v1beta1.UnbondingDelegation": { - "type": "object", - "properties": { - "delegator_address": { - "type": "string", - "format": "byte" - }, - "validator_address": { - "type": "string", - "format": "byte" - }, - "entries": { - "type": "array", - "items": { - "$ref": "#/definitions/cosmos.staking.v1beta1.UnbondingDelegationEntry" - } - } - }, - "title": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list" - }, - "cosmos.staking.v1beta1.UnbondingDelegationEntry": { - "type": "object", - "properties": { - "creation_height": { - "type": "string", - "format": "int64" - }, - "completion_time": { - "type": "string", - "format": "date-time" - }, - "initial_balance": { - "type": "string" - }, - "balance": { - "type": "string" - } - }, - "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." - }, - "cosmos.staking.v1beta1.Validator": { - "type": "object", - "properties": { - "operator_address": { - "type": "string", - "format": "byte" - }, - "consensus_pubkey": { - "type": "string" - }, - "jailed": { - "type": "boolean", - "format": "boolean" - }, - "status": { - "type": "integer", - "format": "int32" - }, - "tokens": { - "type": "string" - }, - "delegator_shares": { - "type": "string" - }, - "description": { - "$ref": "#/definitions/cosmos.staking.v1beta1.Description" - }, - "unbonding_height": { - "type": "string", - "format": "int64" - }, - "unbonding_time": { - "type": "string", - "format": "date-time" - }, - "commission": { - "$ref": "#/definitions/cosmos.staking.v1beta1.Commission" - }, - "min_self_delegation": { - "type": "string" - } - }, - "description": "Validator defines the total amount of bond shares and their exchange rate to\ncoins. Slashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." - }, - "google.protobuf.Any": { - "type": "object", - "properties": { - "type_url": { - "type": "string" - }, - "value": { - "type": "string", - "format": "byte" - } - } - }, - "grpc.gateway.runtime.Error": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/google.protobuf.Any" - } - } - } - }, - "tendermint.types.BlockID": { - "type": "object", - "properties": { - "hash": { - "type": "string", - "format": "byte" - }, - "part_set_header": { - "$ref": "#/definitions/tendermint.types.PartSetHeader" - } - }, - "title": "BlockID" - }, - "tendermint.types.Header": { - "type": "object", - "properties": { - "version": { - "$ref": "#/definitions/tendermint.version.Consensus", - "title": "basic block info" - }, - "chain_id": { - "type": "string" - }, - "height": { - "type": "string", - "format": "int64" - }, - "time": { - "type": "string", - "format": "date-time" - }, - "last_block_id": { - "$ref": "#/definitions/tendermint.types.BlockID", - "title": "prev block info" - }, - "last_commit_hash": { - "type": "string", - "format": "byte", - "title": "hashes of block data" - }, - "data_hash": { - "type": "string", - "format": "byte" - }, - "validators_hash": { - "type": "string", - "format": "byte", - "title": "hashes from the app output from the prev block" - }, - "next_validators_hash": { - "type": "string", - "format": "byte" - }, - "consensus_hash": { - "type": "string", - "format": "byte" - }, - "app_hash": { - "type": "string", - "format": "byte" - }, - "last_results_hash": { - "type": "string", - "format": "byte" - }, - "evidence_hash": { - "type": "string", - "format": "byte", - "title": "consensus info" - }, - "proposer_address": { - "type": "string", - "format": "byte" - } - }, - "description": "Header defines the structure of a Tendermint block header." - }, - "tendermint.types.PartSetHeader": { - "type": "object", - "properties": { - "total": { - "type": "integer", - "format": "int64" - }, - "hash": { - "type": "string", - "format": "byte" - } - }, - "title": "PartsetHeader" - }, - "tendermint.version.Consensus": { - "type": "object", - "properties": { - "block": { - "type": "string", - "format": "uint64" - }, - "app": { - "type": "string", - "format": "uint64" - } - }, - "description": "Consensus captures the consensus rules for processing a block in the blockchain,\nincluding all blockchain data structures and the rules of the application's\nstate transition machine." - } - } -} diff --git a/cosmos/upgrade/v1beta1/query.swagger.json b/cosmos/upgrade/v1beta1/query.swagger.json deleted file mode 100644 index dc1c49eebb58..000000000000 --- a/cosmos/upgrade/v1beta1/query.swagger.json +++ /dev/null @@ -1,150 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "cosmos/upgrade/v1beta1/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/cosmos/upgrade/v1beta1/applied_plan/{name}": { - "get": { - "summary": "AppliedPlan queries a previously applied upgrade plan by its name.", - "operationId": "AppliedPlan", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.upgrade.v1beta1.QueryAppliedPlanResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "name", - "description": "name is the name of the applied plan to query for.", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - }, - "/cosmos/upgrade/v1beta1/current_plan": { - "get": { - "summary": "CurrentPlan queries the current upgrade plan.", - "operationId": "CurrentPlan", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/cosmos.upgrade.v1beta1.QueryCurrentPlanResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "cosmos.upgrade.v1beta1.Plan": { - "type": "object", - "properties": { - "name": { - "type": "string", - "description": "Sets the name for the upgrade. This name will be used by the upgraded version of the software to apply any\nspecial \"on-upgrade\" commands during the first BeginBlock method after the upgrade is applied. It is also used\nto detect whether a software version can handle a given upgrade. If no upgrade handler with this name has been\nset in the software, it will be assumed that the software is out-of-date when the upgrade Time or Height\nis reached and the software will exit." - }, - "time": { - "type": "string", - "format": "date-time", - "description": "The time after which the upgrade must be performed.\nLeave set to its zero value to use a pre-defined Height instead." - }, - "height": { - "type": "string", - "format": "int64", - "description": "The height at which the upgrade must be performed.\nOnly used if Time is not set." - }, - "info": { - "type": "string", - "title": "Any application specific upgrade info to be included on-chain\nsuch as a git commit that validators could automatically upgrade to" - } - }, - "title": "Plan specifies information about a planned upgrade and when it should occur" - }, - "cosmos.upgrade.v1beta1.QueryAppliedPlanResponse": { - "type": "object", - "properties": { - "height": { - "type": "string", - "format": "int64", - "description": "height is the block height at which the plan was applied." - } - }, - "description": "QueryAppliedPlanResponse is the response type for the Query/AppliedPlan RPC method." - }, - "cosmos.upgrade.v1beta1.QueryCurrentPlanResponse": { - "type": "object", - "properties": { - "plan": { - "$ref": "#/definitions/cosmos.upgrade.v1beta1.Plan", - "description": "plan is the current upgrade plan." - } - }, - "description": "QueryCurrentPlanResponse is the response type for the Query/CurrentPlan RPC method." - }, - "google.protobuf.Any": { - "type": "object", - "properties": { - "type_url": { - "type": "string" - }, - "value": { - "type": "string", - "format": "byte" - } - } - }, - "grpc.gateway.runtime.Error": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/google.protobuf.Any" - } - } - } - } - } -} diff --git a/ibc/channel/query.swagger.json b/ibc/channel/query.swagger.json deleted file mode 100644 index 3dd6b7074f87..000000000000 --- a/ibc/channel/query.swagger.json +++ /dev/null @@ -1,982 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "ibc/channel/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/ibc/channel/v1beta1/channels": { - "get": { - "summary": "Channels queries all the IBC channels of a chain.", - "operationId": "Channels", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/ibc.channel.QueryChannelsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}": { - "get": { - "summary": "Channel queries an IBC Channel.", - "operationId": "Channel", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/ibc.channel.QueryChannelResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "channel_id", - "description": "channel unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "port_id", - "description": "port unique identifier", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/client_state": { - "get": { - "summary": "ChannelClientState queries for the client state for the channel associated\nwith the provided channel identifiers.", - "operationId": "ChannelClientState", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/ibc.channel.QueryChannelClientStateResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "channel_id", - "description": "channel unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "port_id", - "description": "port unique identifier", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/consensus_state/{height}": { - "get": { - "summary": "ChannelConsensusState queries for the consensus state for the channel\nassociated with the provided channel identifiers.", - "operationId": "ChannelConsensusState", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/ibc.channel.QueryChannelConsensusStateResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "channel_id", - "description": "channel unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "port_id", - "description": "port unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "height", - "description": "height of the consensus state", - "in": "path", - "required": true, - "type": "string", - "format": "uint64" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/next_sequence": { - "get": { - "summary": "NextSequenceReceive returns the next receive sequence for a given channel.", - "operationId": "NextSequenceReceive", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/ibc.channel.QueryNextSequenceReceiveResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "channel_id", - "description": "channel unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "port_id", - "description": "port unique identifier", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_acks/{sequence}": { - "get": { - "summary": "PacketAcknowledgement queries a stored packet acknowledgement hash.", - "operationId": "PacketAcknowledgement", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/ibc.channel.QueryPacketAcknowledgementResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "channel_id", - "description": "channel unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "port_id", - "description": "port unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "sequence", - "description": "packet sequence", - "in": "path", - "required": true, - "type": "string", - "format": "uint64" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments": { - "get": { - "summary": "PacketCommitments returns the all the packet commitments hashes associated\nwith a channel.", - "operationId": "PacketCommitments", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/ibc.channel.QueryPacketCommitmentsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "channel_id", - "description": "channel unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "port_id", - "description": "port unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_commitment_sequences}/packet_acks/{acknowledgements}/unrelayed_packets": { - "get": { - "summary": "UnrelayedPackets returns all the unrelayed IBC packets associated with a\nchannel and sequences.", - "operationId": "UnrelayedPackets", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/ibc.channel.QueryUnrelayedPacketsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "channel_id", - "description": "channel unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "port_id", - "description": "port unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "packet_commitment_sequences", - "description": "list of packet sequences", - "in": "path", - "required": true, - "type": "array", - "items": { - "type": "string", - "format": "uint64" - }, - "collectionFormat": "csv", - "minItems": 1 - }, - { - "name": "acknowledgements", - "description": "flag indicating if the return value is packet commitments or\nacknowledgements", - "in": "path", - "required": true, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/{sequence}": { - "get": { - "summary": "PacketCommitment queries a stored packet commitment hash.", - "operationId": "PacketCommitment", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/ibc.channel.QueryPacketCommitmentResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "channel_id", - "description": "channel unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "port_id", - "description": "port unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "sequence", - "description": "packet sequence", - "in": "path", - "required": true, - "type": "string", - "format": "uint64" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/channel/v1beta1/connections/{connection}/channels": { - "get": { - "summary": "ConnectionChannels queries all the channels associated with a connection\nend.", - "operationId": "ConnectionChannels", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/ibc.channel.QueryConnectionChannelsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "connection", - "description": "connection unique identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "cosmos.base.query.v1beta1.PageRequest": { - "type": "object", - "properties": { - "key": { - "type": "string", - "format": "byte", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." - }, - "offset": { - "type": "string", - "format": "uint64", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." - }, - "limit": { - "type": "string", - "format": "uint64", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." - }, - "count_total": { - "type": "boolean", - "format": "boolean", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." - } - }, - "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", - "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" - }, - "cosmos.base.query.v1beta1.PageResponse": { - "type": "object", - "properties": { - "next_key": { - "type": "string", - "format": "byte", - "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" - }, - "total": { - "type": "string", - "format": "uint64", - "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" - } - }, - "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" - }, - "google.protobuf.Any": { - "type": "object", - "properties": { - "type_url": { - "type": "string", - "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." - }, - "value": { - "type": "string", - "format": "byte", - "description": "Must be a valid serialized protocol buffer of the above specified type." - } - }, - "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := \u0026pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" - }, - "grpc.gateway.runtime.Error": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/google.protobuf.Any" - } - } - } - }, - "ibc.channel.Channel": { - "type": "object", - "properties": { - "state": { - "$ref": "#/definitions/ibc.channel.State", - "title": "current state of the channel end" - }, - "ordering": { - "$ref": "#/definitions/ibc.channel.Order", - "title": "whether the channel is ordered or unordered" - }, - "counterparty": { - "$ref": "#/definitions/ibc.channel.Counterparty", - "title": "counterparty channel end" - }, - "connection_hops": { - "type": "array", - "items": { - "type": "string" - }, - "title": "list of connection identifiers, in order, along which packets sent on this\nchannel will travel" - }, - "version": { - "type": "string", - "title": "opaque channel version, which is agreed upon during the handshake" - } - }, - "description": "Channel defines pipeline for exactly-once packet delivery between specific\nmodules on separate blockchains, which has at least one end capable of sending\npackets and one end capable of receiving packets." - }, - "ibc.channel.Counterparty": { - "type": "object", - "properties": { - "port_id": { - "type": "string", - "description": "port on the counterparty chain which owns the other end of the channel." - }, - "channel_id": { - "type": "string", - "title": "channel end on the counterparty chain" - } - }, - "title": "Counterparty defines a channel end counterparty" - }, - "ibc.channel.IdentifiedChannel": { - "type": "object", - "properties": { - "state": { - "$ref": "#/definitions/ibc.channel.State", - "title": "current state of the channel end" - }, - "ordering": { - "$ref": "#/definitions/ibc.channel.Order", - "title": "whether the channel is ordered or unordered" - }, - "counterparty": { - "$ref": "#/definitions/ibc.channel.Counterparty", - "title": "counterparty channel end" - }, - "connection_hops": { - "type": "array", - "items": { - "type": "string" - }, - "title": "list of connection identifiers, in order, along which packets sent on this\nchannel will travel" - }, - "version": { - "type": "string", - "title": "opaque channel version, which is agreed upon during the handshake" - }, - "port_id": { - "type": "string", - "title": "port identifier" - }, - "channel_id": { - "type": "string", - "title": "channel identifier" - } - }, - "description": "IdentifiedChannel defines a channel with additional port and channel identifier\nfields." - }, - "ibc.channel.Order": { - "type": "string", - "enum": [ - "ORDER_NONE_UNSPECIFIED", - "ORDER_UNORDERED", - "ORDER_ORDERED" - ], - "default": "ORDER_NONE_UNSPECIFIED", - "description": "- ORDER_NONE_UNSPECIFIED: zero-value for channel ordering\n - ORDER_UNORDERED: packets can be delivered in any order, which may differ from the order in which they were sent.\n - ORDER_ORDERED: packets are delivered exactly in the order which they were sent", - "title": "Order defines if a channel is ORDERED or UNORDERED" - }, - "ibc.channel.PacketAckCommitment": { - "type": "object", - "properties": { - "port_id": { - "type": "string", - "description": "channel port identifier." - }, - "channel_id": { - "type": "string", - "description": "channel unique identifier." - }, - "sequence": { - "type": "string", - "format": "uint64", - "description": "packet sequence." - }, - "hash": { - "type": "string", - "format": "byte", - "description": "packet commitment hash." - } - }, - "description": "PacketAckCommitment defines the genesis type necessary to retrieve and store\nacknowlegements." - }, - "ibc.channel.QueryChannelClientStateResponse": { - "type": "object", - "properties": { - "identified_client_state": { - "$ref": "#/definitions/ibc.client.IdentifiedClientState", - "title": "client state associated with the channel" - }, - "proof": { - "type": "string", - "format": "byte", - "title": "merkle proof of existence" - }, - "proof_path": { - "type": "string", - "title": "merkle proof path" - }, - "proof_height": { - "type": "string", - "format": "uint64", - "title": "height at which the proof was retrieved" - } - }, - "title": "QueryChannelClientStateResponse is the Response type for the\nQuery/QueryChannelClientState RPC method" - }, - "ibc.channel.QueryChannelConsensusStateResponse": { - "type": "object", - "properties": { - "consensus_state": { - "$ref": "#/definitions/google.protobuf.Any", - "title": "consensus state associated with the channel" - }, - "client_id": { - "type": "string", - "title": "client ID associated with the consensus state" - }, - "proof": { - "type": "string", - "format": "byte", - "title": "merkle proof of existence" - }, - "proof_path": { - "type": "string", - "title": "merkle proof path" - }, - "proof_height": { - "type": "string", - "format": "uint64", - "title": "height at which the proof was retrieved" - } - }, - "title": "QueryChannelClientStateResponse is the Response type for the\nQuery/QueryChannelClientState RPC method" - }, - "ibc.channel.QueryChannelResponse": { - "type": "object", - "properties": { - "channel": { - "$ref": "#/definitions/ibc.channel.Channel", - "title": "channel associated with the request identifiers" - }, - "proof": { - "type": "string", - "format": "byte", - "title": "merkle proof of existence" - }, - "proof_path": { - "type": "string", - "title": "merkle proof path" - }, - "proof_height": { - "type": "string", - "format": "uint64", - "title": "height at which the proof was retrieved" - } - }, - "description": "QueryChannelResponse is the response type for the Query/Channel RPC method.\nBesides the Channel end, it includes a proof and the height from which the\nproof was retrieved." - }, - "ibc.channel.QueryChannelsResponse": { - "type": "object", - "properties": { - "channels": { - "type": "array", - "items": { - "$ref": "#/definitions/ibc.channel.IdentifiedChannel" - }, - "description": "list of stored channels of the chain." - }, - "pagination": { - "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", - "title": "pagination response" - }, - "height": { - "type": "string", - "format": "int64", - "title": "query block height" - } - }, - "description": "QueryChannelsResponse is the response type for the Query/Channels RPC method." - }, - "ibc.channel.QueryConnectionChannelsResponse": { - "type": "object", - "properties": { - "channels": { - "type": "array", - "items": { - "$ref": "#/definitions/ibc.channel.IdentifiedChannel" - }, - "description": "list of channels associated with a connection." - }, - "pagination": { - "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", - "title": "pagination response" - }, - "height": { - "type": "string", - "format": "int64", - "title": "query block height" - } - }, - "title": "QueryConnectionChannelsResponse is the Response type for the\nQuery/QueryConnectionChannels RPC method" - }, - "ibc.channel.QueryNextSequenceReceiveResponse": { - "type": "object", - "properties": { - "next_sequence_receive": { - "type": "string", - "format": "uint64", - "title": "next sequence receive number" - }, - "proof": { - "type": "string", - "format": "byte", - "title": "merkle proof of existence" - }, - "proof_path": { - "type": "string", - "title": "merkle proof path" - }, - "proof_height": { - "type": "string", - "format": "uint64", - "title": "height at which the proof was retrieved" - } - }, - "title": "QuerySequenceResponse is the request type for the\nQuery/QueryNextSequenceReceiveResponse RPC method" - }, - "ibc.channel.QueryPacketAcknowledgementResponse": { - "type": "object", - "properties": { - "acknowledgement": { - "type": "string", - "format": "byte", - "title": "packet associated with the request fields" - }, - "proof": { - "type": "string", - "format": "byte", - "title": "merkle proof of existence" - }, - "proof_path": { - "type": "string", - "title": "merkle proof path" - }, - "proof_height": { - "type": "string", - "format": "uint64", - "title": "height at which the proof was retrieved" - } - }, - "title": "QueryPacketAcknowledgementResponse defines the client query response for a\npacket which also includes a proof, its path and the height form which the\nproof was retrieved" - }, - "ibc.channel.QueryPacketCommitmentResponse": { - "type": "object", - "properties": { - "commitment": { - "type": "string", - "format": "byte", - "title": "packet associated with the request fields" - }, - "proof": { - "type": "string", - "format": "byte", - "title": "merkle proof of existence" - }, - "proof_path": { - "type": "string", - "title": "merkle proof path" - }, - "proof_height": { - "type": "string", - "format": "uint64", - "title": "height at which the proof was retrieved" - } - }, - "title": "QueryPacketCommitmentResponse defines the client query response for a packet\nwhich also includes a proof, its path and the height form which the proof was\nretrieved" - }, - "ibc.channel.QueryPacketCommitmentsResponse": { - "type": "object", - "properties": { - "commitments": { - "type": "array", - "items": { - "$ref": "#/definitions/ibc.channel.PacketAckCommitment" - } - }, - "pagination": { - "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", - "title": "pagination response" - }, - "height": { - "type": "string", - "format": "int64", - "title": "query block height" - } - }, - "title": "QueryPacketCommitmentsResponse is the request type for the\nQuery/QueryPacketCommitments RPC method" - }, - "ibc.channel.QueryUnrelayedPacketsResponse": { - "type": "object", - "properties": { - "sequences": { - "type": "array", - "items": { - "type": "string", - "format": "uint64" - }, - "title": "list of unrelayed packet sequences" - }, - "height": { - "type": "string", - "format": "int64", - "title": "query block height" - } - }, - "title": "QueryUnrelayedPacketsResponse is the request type for the\nQuery/UnrelayedPacketCommitments RPC method" - }, - "ibc.channel.State": { - "type": "string", - "enum": [ - "STATE_UNINITIALIZED_UNSPECIFIED", - "STATE_INIT", - "STATE_TRYOPEN", - "STATE_OPEN", - "STATE_CLOSED" - ], - "default": "STATE_UNINITIALIZED_UNSPECIFIED", - "description": "State defines if a channel is in one of the following states:\nCLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.\n\n - STATE_UNINITIALIZED_UNSPECIFIED: Default State\n - STATE_INIT: A channel has just started the opening handshake.\n - STATE_TRYOPEN: A channel has acknowledged the handshake step on the counterparty chain.\n - STATE_OPEN: A channel has completed the handshake. Open channels are\nready to send and receive packets.\n - STATE_CLOSED: A channel has been closed and can no longer be used to send or receive packets." - }, - "ibc.client.IdentifiedClientState": { - "type": "object", - "properties": { - "id": { - "type": "string", - "title": "client identifier" - }, - "client_state": { - "$ref": "#/definitions/google.protobuf.Any" - } - }, - "description": "IdentifiedClientState defines a client state with additional client identifier field." - } - } -} diff --git a/ibc/connection/query.swagger.json b/ibc/connection/query.swagger.json deleted file mode 100644 index 5c648c1d9deb..000000000000 --- a/ibc/connection/query.swagger.json +++ /dev/null @@ -1,520 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "ibc/connection/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/ibc/connection/v1beta1/client_connections/{client_id}": { - "get": { - "summary": "ClientConnections queries the connection paths associated with a client\nstate.", - "operationId": "ClientConnections", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/ibc.connection.QueryClientConnectionsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "client_id", - "description": "client identifier associated with a connection", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/connection/v1beta1/connections": { - "get": { - "summary": "Connections queries all the IBC connections of a chain.", - "operationId": "Connections", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/ibc.connection.QueryConnectionsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/connection/v1beta1/connections/{connection_id}": { - "get": { - "summary": "Connection queries an IBC connection end.", - "operationId": "Connection", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/ibc.connection.QueryConnectionResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "connection_id", - "description": "connection unique identifier", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/connection/v1beta1/connections/{connection_id}/client_state": { - "get": { - "summary": "ConnectionClientState queries the client state associated with the\nconnection.", - "operationId": "ConnectionClientState", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/ibc.connection.QueryConnectionClientStateResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "connection_id", - "description": "connection identifier", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc/connection/v1beta1/connections/{connection_id}/consensus_state": { - "get": { - "summary": "ConnectionConsensusState queries the consensus state associated with the\nconnection.", - "operationId": "ConnectionConsensusState", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/ibc.connection.QueryConnectionConsensusStateResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "connection_id", - "description": "connection identifier", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "height", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - } - ], - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "cosmos.base.query.v1beta1.PageRequest": { - "type": "object", - "properties": { - "key": { - "type": "string", - "format": "byte", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." - }, - "offset": { - "type": "string", - "format": "uint64", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." - }, - "limit": { - "type": "string", - "format": "uint64", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." - }, - "count_total": { - "type": "boolean", - "format": "boolean", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." - } - }, - "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", - "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" - }, - "cosmos.base.query.v1beta1.PageResponse": { - "type": "object", - "properties": { - "next_key": { - "type": "string", - "format": "byte", - "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" - }, - "total": { - "type": "string", - "format": "uint64", - "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" - } - }, - "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" - }, - "google.protobuf.Any": { - "type": "object", - "properties": { - "type_url": { - "type": "string", - "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." - }, - "value": { - "type": "string", - "format": "byte", - "description": "Must be a valid serialized protocol buffer of the above specified type." - } - }, - "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(\u0026foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := \u0026pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := \u0026pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": \u003cstring\u003e,\n \"lastName\": \u003cstring\u003e\n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" - }, - "grpc.gateway.runtime.Error": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/google.protobuf.Any" - } - } - } - }, - "ibc.client.IdentifiedClientState": { - "type": "object", - "properties": { - "id": { - "type": "string", - "title": "client identifier" - }, - "client_state": { - "$ref": "#/definitions/google.protobuf.Any" - } - }, - "description": "IdentifiedClientState defines a client state with additional client identifier field." - }, - "ibc.commitment.MerklePrefix": { - "type": "object", - "properties": { - "key_prefix": { - "type": "string", - "format": "byte" - } - }, - "title": "MerklePrefix is merkle path prefixed to the key.\nThe constructed key from the Path and the key will be append(Path.KeyPath, append(Path.KeyPrefix, key...))" - }, - "ibc.connection.ConnectionEnd": { - "type": "object", - "properties": { - "client_id": { - "type": "string", - "description": "client associated with this connection." - }, - "versions": { - "type": "array", - "items": { - "type": "string" - }, - "title": "IBC version which can be utilised to determine encodings or protocols for\nchannels or packets utilising this connection" - }, - "state": { - "$ref": "#/definitions/ibc.connection.State", - "description": "current state of the connection end." - }, - "counterparty": { - "$ref": "#/definitions/ibc.connection.Counterparty", - "description": "counterparty chain associated with this connection." - } - }, - "description": "ConnectionEnd defines a stateful object on a chain connected to another\nseparate one. NOTE: there must only be 2 defined ConnectionEnds to establish\na connection between two chains." - }, - "ibc.connection.Counterparty": { - "type": "object", - "properties": { - "client_id": { - "type": "string", - "description": "identifies the client on the counterparty chain associated with a given\nconnection." - }, - "connection_id": { - "type": "string", - "description": "identifies the connection end on the counterparty chain associated with a\ngiven connection." - }, - "prefix": { - "$ref": "#/definitions/ibc.commitment.MerklePrefix", - "title": "commitment merkle prefix of the counterparty chain" - } - }, - "description": "Counterparty defines the counterparty chain associated with a connection end." - }, - "ibc.connection.IdentifiedConnection": { - "type": "object", - "properties": { - "id": { - "type": "string", - "description": "connection identifier." - }, - "client_id": { - "type": "string", - "description": "client associated with this connection." - }, - "versions": { - "type": "array", - "items": { - "type": "string" - }, - "title": "IBC version which can be utilised to determine encodings or protocols for\nchannels or packets utilising this connection" - }, - "state": { - "$ref": "#/definitions/ibc.connection.State", - "description": "current state of the connection end." - }, - "counterparty": { - "$ref": "#/definitions/ibc.connection.Counterparty", - "description": "counterparty chain associated with this connection." - } - }, - "description": "IdentifiedConnection defines a connection with additional connection\nidentifier field." - }, - "ibc.connection.QueryClientConnectionsResponse": { - "type": "object", - "properties": { - "connection_paths": { - "type": "array", - "items": { - "type": "string" - }, - "description": "slice of all the connection paths associated with a client." - }, - "proof": { - "type": "string", - "format": "byte", - "title": "merkle proof of existence" - }, - "proof_path": { - "type": "string", - "title": "merkle proof path" - }, - "proof_height": { - "type": "string", - "format": "uint64", - "title": "height at which the proof was generated" - } - }, - "title": "QueryClientConnectionsResponse is the response type for the\nQuery/ClientConnections RPC method" - }, - "ibc.connection.QueryConnectionClientStateResponse": { - "type": "object", - "properties": { - "identified_client_state": { - "$ref": "#/definitions/ibc.client.IdentifiedClientState", - "title": "client state associated with the channel" - }, - "proof": { - "type": "string", - "format": "byte", - "title": "merkle proof of existence" - }, - "proof_path": { - "type": "string", - "title": "merkle proof path" - }, - "proof_height": { - "type": "string", - "format": "uint64", - "title": "height at which the proof was retrieved" - } - }, - "title": "QueryConnectionClientStateResponse is the response type for the\nQuery/ConnectionClientState RPC method" - }, - "ibc.connection.QueryConnectionConsensusStateResponse": { - "type": "object", - "properties": { - "consensus_state": { - "$ref": "#/definitions/google.protobuf.Any", - "title": "consensus state associated with the channel" - }, - "client_id": { - "type": "string", - "title": "client ID associated with the consensus state" - }, - "proof": { - "type": "string", - "format": "byte", - "title": "merkle proof of existence" - }, - "proof_path": { - "type": "string", - "title": "merkle proof path" - }, - "proof_height": { - "type": "string", - "format": "uint64", - "title": "height at which the proof was retrieved" - } - }, - "title": "QueryConnectionConsensusStateResponse is the response type for the\nQuery/ConnectionConsensusState RPC method" - }, - "ibc.connection.QueryConnectionResponse": { - "type": "object", - "properties": { - "connection": { - "$ref": "#/definitions/ibc.connection.ConnectionEnd", - "title": "connection associated with the request identifier" - }, - "proof": { - "type": "string", - "format": "byte", - "title": "merkle proof of existence" - }, - "proof_path": { - "type": "string", - "title": "merkle proof path" - }, - "proof_height": { - "type": "string", - "format": "uint64", - "title": "height at which the proof was retrieved" - } - }, - "description": "QueryConnectionResponse is the response type for the Query/Connection RPC\nmethod. Besides the connection end, it includes a proof and the height from\nwhich the proof was retrieved." - }, - "ibc.connection.QueryConnectionsResponse": { - "type": "object", - "properties": { - "connections": { - "type": "array", - "items": { - "$ref": "#/definitions/ibc.connection.IdentifiedConnection" - }, - "description": "list of stored connections of the chain." - }, - "pagination": { - "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", - "title": "pagination response" - }, - "height": { - "type": "string", - "format": "int64", - "title": "query block height" - } - }, - "description": "QueryConnectionsResponse is the response type for the Query/Connections RPC\nmethod." - }, - "ibc.connection.State": { - "type": "string", - "enum": [ - "STATE_UNINITIALIZED_UNSPECIFIED", - "STATE_INIT", - "STATE_TRYOPEN", - "STATE_OPEN" - ], - "default": "STATE_UNINITIALIZED_UNSPECIFIED", - "description": "State defines if a connection is in one of the following states:\nINIT, TRYOPEN, OPEN or UNINITIALIZED.\n\n - STATE_UNINITIALIZED_UNSPECIFIED: Default State\n - STATE_INIT: A connection end has just started the opening handshake.\n - STATE_TRYOPEN: A connection end has acknowledged the handshake step on the counterparty\nchain.\n - STATE_OPEN: A connection end has completed the handshake." - } - } -} diff --git a/ibc/transfer/query.swagger.json b/ibc/transfer/query.swagger.json deleted file mode 100644 index 2e04eea37fdb..000000000000 --- a/ibc/transfer/query.swagger.json +++ /dev/null @@ -1,273 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "ibc/transfer/query.proto", - "version": "version not set" - }, - "consumes": [ - "application/json" - ], - "produces": [ - "application/json" - ], - "paths": { - "/ibc_transfer/v1beta1/denom_traces": { - "get": { - "summary": "DenomTraces queries all denomination traces.", - "operationId": "DenomTraces", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/ibc.transfer.QueryDenomTracesResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "pagination.key", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", - "in": "query", - "required": false, - "type": "string", - "format": "byte" - }, - { - "name": "pagination.offset", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.limit", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", - "in": "query", - "required": false, - "type": "string", - "format": "uint64" - }, - { - "name": "pagination.count_total", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", - "in": "query", - "required": false, - "type": "boolean", - "format": "boolean" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc_transfer/v1beta1/denom_traces/{hash}": { - "get": { - "summary": "DenomTrace queries a denomination trace information.", - "operationId": "DenomTrace", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/ibc.transfer.QueryDenomTraceResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "parameters": [ - { - "name": "hash", - "description": "hash (in hex format) of the denomination trace information.", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": [ - "Query" - ] - } - }, - "/ibc_transfer/v1beta1/params": { - "get": { - "summary": "Params queries all parameters of the ibc-transfer module.", - "operationId": "Params", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/ibc.transfer.QueryParamsResponse" - } - }, - "default": { - "description": "An unexpected error response", - "schema": { - "$ref": "#/definitions/grpc.gateway.runtime.Error" - } - } - }, - "tags": [ - "Query" - ] - } - } - }, - "definitions": { - "cosmos.base.query.v1beta1.PageRequest": { - "type": "object", - "properties": { - "key": { - "type": "string", - "format": "byte", - "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set." - }, - "offset": { - "type": "string", - "format": "uint64", - "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set." - }, - "limit": { - "type": "string", - "format": "uint64", - "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app." - }, - "count_total": { - "type": "boolean", - "format": "boolean", - "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set." - } - }, - "description": "message SomeRequest {\n Foo some_parameter = 1;\n PageRequest pagination = 2;\n }", - "title": "PageRequest is to be embedded in gRPC request messages for efficient\npagination. Ex:" - }, - "cosmos.base.query.v1beta1.PageResponse": { - "type": "object", - "properties": { - "next_key": { - "type": "string", - "format": "byte", - "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" - }, - "total": { - "type": "string", - "format": "uint64", - "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" - } - }, - "description": "message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }", - "title": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest" - }, - "google.protobuf.Any": { - "type": "object", - "properties": { - "type_url": { - "type": "string" - }, - "value": { - "type": "string", - "format": "byte" - } - } - }, - "grpc.gateway.runtime.Error": { - "type": "object", - "properties": { - "error": { - "type": "string" - }, - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/google.protobuf.Any" - } - } - } - }, - "ibc.transfer.DenomTrace": { - "type": "object", - "properties": { - "path": { - "type": "string", - "description": "path defines the chain of port/channel identifiers used for tracing the source of the fungible\ntoken." - }, - "base_denom": { - "type": "string", - "description": "base denomination of the relayed fungible token." - } - }, - "description": "DenomTrace contains the base denomination for ICS20 fungible tokens and the source tracing\ninformation path." - }, - "ibc.transfer.Params": { - "type": "object", - "properties": { - "send_enabled": { - "type": "boolean", - "format": "boolean", - "description": "send_enabled enables or disables all cross-chain token transfers from this chain." - }, - "receive_enabled": { - "type": "boolean", - "format": "boolean", - "description": "receive_enabled enables or disables all cross-chain token transfers to this chain." - } - }, - "description": "Params defines the set of IBC transfer parameters.\nNOTE: To prevent a single token from being transferred, set the TransfersEnabled parameter to\ntrue and then set the bank module's SendEnabled parameter for the denomination to false." - }, - "ibc.transfer.QueryDenomTraceResponse": { - "type": "object", - "properties": { - "denom_trace": { - "$ref": "#/definitions/ibc.transfer.DenomTrace", - "description": "denom_trace returns the requested denomination trace information." - } - }, - "description": "QueryDenomTraceResponse is the response type for the Query/DenomTrace RPC method." - }, - "ibc.transfer.QueryDenomTracesResponse": { - "type": "object", - "properties": { - "denom_traces": { - "type": "array", - "items": { - "$ref": "#/definitions/ibc.transfer.DenomTrace" - }, - "description": "denom_traces returns all denominations trace information." - }, - "pagination": { - "$ref": "#/definitions/cosmos.base.query.v1beta1.PageResponse", - "description": "pagination defines the pagination in the response." - } - }, - "description": "QueryConnectionsResponse is the response type for the Query/DenomTraces RPC method." - }, - "ibc.transfer.QueryParamsResponse": { - "type": "object", - "properties": { - "params": { - "$ref": "#/definitions/ibc.transfer.Params", - "description": "params defines the parameters of the module." - } - }, - "description": "QueryParamsResponse is the response type for the Query/Params RPC method." - } - } -} diff --git a/scripts/protocgen.sh b/scripts/protocgen.sh index 77db73579050..76523f0c2b90 100755 --- a/scripts/protocgen.sh +++ b/scripts/protocgen.sh @@ -29,6 +29,12 @@ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. \ fi done +# combine swagger files +swagger-combine ./client/grpc-gateway/config.json -o ./client/grpc-gateway/swagger.json --continueOnConflictingPaths true --includeDefinitions true + +# clean swagger files +find ./ -name 'query.swagger.json' -exec rm {} \; + # generate codec/testdata proto code protoc -I "proto" -I "third_party/proto" -I "testutil/testdata" --gocosmos_out=plugins=interfacetype+grpc,\ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. ./testutil/testdata/proto.proto @@ -36,5 +42,3 @@ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. ./testutil # move proto files to the right places cp -r github.com/cosmos/cosmos-sdk/* ./ rm -rf github.com - -swagger-combine ./client/grpc-gateway/config.json -o ./client/grpc-gateway/swagger.json --continueOnConflictingPaths true --includeDefinitions true From 7ced20325b333915f2519d7ecc99e751c7ce12c3 Mon Sep 17 00:00:00 2001 From: anilCSE Date: Sat, 22 Aug 2020 17:18:06 +0530 Subject: [PATCH 18/27] refactor --- client/grpc-gateway/config.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/client/grpc-gateway/config.json b/client/grpc-gateway/config.json index 038bb288afc2..2a759791530a 100644 --- a/client/grpc-gateway/config.json +++ b/client/grpc-gateway/config.json @@ -87,4 +87,4 @@ } } ] -} \ No newline at end of file +} From e1fcaaa175a2e08e0c3ade33107b36d6f158ff60 Mon Sep 17 00:00:00 2001 From: anilCSE Date: Sat, 22 Aug 2020 17:22:12 +0530 Subject: [PATCH 19/27] Fix doc --- scripts/protocgen.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/scripts/protocgen.sh b/scripts/protocgen.sh index 76523f0c2b90..747d3a45e294 100755 --- a/scripts/protocgen.sh +++ b/scripts/protocgen.sh @@ -30,6 +30,7 @@ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. \ done # combine swagger files +# uses nodejs package `swagger-combine`. swagger-combine ./client/grpc-gateway/config.json -o ./client/grpc-gateway/swagger.json --continueOnConflictingPaths true --includeDefinitions true # clean swagger files From e951e6da0bd6b43c65e87ab419b8a27b23194471 Mon Sep 17 00:00:00 2001 From: anilCSE Date: Mon, 24 Aug 2020 18:37:15 +0530 Subject: [PATCH 20/27] move proto-swagger-gen to a separate target --- Makefile | 5 ++++- contrib/devtools/Makefile | 1 + scripts/protoc-swagger-gen.sh | 24 ++++++++++++++++++++++++ 3 files changed, 29 insertions(+), 1 deletion(-) create mode 100644 scripts/protoc-swagger-gen.sh diff --git a/Makefile b/Makefile index 447925e3cf75..7019b9c97838 100644 --- a/Makefile +++ b/Makefile @@ -312,7 +312,7 @@ devdoc-update: ### Protobuf ### ############################################################################### -proto-all: proto-tools proto-gen proto-lint proto-check-breaking +proto-all: proto-tools proto-gen proto-lint proto-check-breaking proto-swagger-gen proto-gen: @./scripts/protocgen.sh @@ -321,6 +321,9 @@ proto-gen: proto-gen-any: @./scripts/protocgen-any.sh +proto-swagger-gen: + @./scripts/protoc-swagger-gen.sh + proto-lint: @buf check lint --error-format=json diff --git a/contrib/devtools/Makefile b/contrib/devtools/Makefile index d1908690eb5a..ba0829cc781a 100644 --- a/contrib/devtools/Makefile +++ b/contrib/devtools/Makefile @@ -118,6 +118,7 @@ endif ifeq (, $(shell which protoc-gen-swagger)) @echo "Installing protoc-gen-swagger..." @go install github.com/grpc-ecosystem/grpc-gateway/protoc-gen-swagger + @npm install -g swagger-combine else @echo "protoc-gen-grpc-gateway already installed; skipping..." endif diff --git a/scripts/protoc-swagger-gen.sh b/scripts/protoc-swagger-gen.sh new file mode 100644 index 000000000000..48a54a2c8806 --- /dev/null +++ b/scripts/protoc-swagger-gen.sh @@ -0,0 +1,24 @@ +#!/usr/bin/env bash + +set -eo pipefail + +proto_dirs=$(find ./proto -path -prune -o -name '*.proto' -print0 | xargs -0 -n1 dirname | sort | uniq) +for dir in $proto_dirs; do + + # generate swagger files (filter query files) + query_file=$(find "${dir}" -maxdepth 1 -name 'query.proto') + if [[ ! -z "$query_file" ]]; then + protoc \ + -I "proto" \ + -I "third_party/proto" \ + "$query_file" \ + --swagger_out=logtostderr=true,stderrthreshold=1000,fqn_for_swagger_name=true,simple_operation_ids=true:. + fi +done + +# combine swagger files +# uses nodejs package `swagger-combine`. +swagger-combine ./client/grpc-gateway/config.json -o ./client/grpc-gateway/swagger.json --continueOnConflictingPaths true --includeDefinitions true + +# clean swagger files +find ./ -name 'query.swagger.json' -exec rm {} \; \ No newline at end of file From 81e6289a1716696bedf44fd3088114d6db8ede38 Mon Sep 17 00:00:00 2001 From: anilCSE Date: Thu, 27 Aug 2020 21:53:35 +0530 Subject: [PATCH 21/27] Fix permissions --- scripts/protoc-swagger-gen.sh | 0 1 file changed, 0 insertions(+), 0 deletions(-) mode change 100644 => 100755 scripts/protoc-swagger-gen.sh diff --git a/scripts/protoc-swagger-gen.sh b/scripts/protoc-swagger-gen.sh old mode 100644 new mode 100755 From e5f8ab98bae48fe4fd01a145acf2c9f36f7ee518 Mon Sep 17 00:00:00 2001 From: anilCSE Date: Fri, 28 Aug 2020 00:38:55 +0530 Subject: [PATCH 22/27] Add ibc swagger gen --- client/grpc-gateway/config.json | 32 + client/grpc-gateway/swagger.json | 6160 +++++++++++++++++++++++++----- 2 files changed, 5132 insertions(+), 1060 deletions(-) diff --git a/client/grpc-gateway/config.json b/client/grpc-gateway/config.json index 2a759791530a..bc5692f25173 100644 --- a/client/grpc-gateway/config.json +++ b/client/grpc-gateway/config.json @@ -85,6 +85,38 @@ "Params": "UpgradeParams" } } + }, + { + "url": "./ibc/channel/query.swagger.json", + "operationIds": { + "rename": { + "Params": "IBCChannelParams" + } + } + }, + { + "url": "./ibc/client/query.swagger.json", + "operationIds": { + "rename": { + "Params": "IBCClientParams" + } + } + }, + { + "url": "./ibc/connection/query.swagger.json", + "operationIds": { + "rename": { + "Params": "IBCConnectionParams" + } + } + }, + { + "url": "./ibc/transfer/query.swagger.json", + "operationIds": { + "rename": { + "Params": "IBCTransferParams" + } + } } ] } diff --git a/client/grpc-gateway/swagger.json b/client/grpc-gateway/swagger.json index e6649a0e7c55..3bf32f7df0c6 100644 --- a/client/grpc-gateway/swagger.json +++ b/client/grpc-gateway/swagger.json @@ -5534,6 +5534,2632 @@ "Query" ] } + }, + "/ibc/channel/v1beta1/channels": { + "get": { + "summary": "Channels queries all the IBC channels of a chain.", + "operationId": "Channels", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "channels": { + "type": "array", + "items": { + "type": "object", + "properties": { + "state": { + "title": "current state of the channel end", + "type": "string", + "enum": [ + "STATE_UNINITIALIZED_UNSPECIFIED", + "STATE_INIT", + "STATE_TRYOPEN", + "STATE_OPEN", + "STATE_CLOSED" + ], + "default": "STATE_UNINITIALIZED_UNSPECIFIED", + "description": "State defines if a channel is in one of the following states:\nCLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.\n\n - STATE_UNINITIALIZED_UNSPECIFIED: Default State\n - STATE_INIT: A channel has just started the opening handshake.\n - STATE_TRYOPEN: A channel has acknowledged the handshake step on the counterparty chain.\n - STATE_OPEN: A channel has completed the handshake. Open channels are\nready to send and receive packets.\n - STATE_CLOSED: A channel has been closed and can no longer be used to send or receive\npackets." + }, + "ordering": { + "title": "whether the channel is ordered or unordered", + "type": "string", + "enum": [ + "ORDER_NONE_UNSPECIFIED", + "ORDER_UNORDERED", + "ORDER_ORDERED" + ], + "default": "ORDER_NONE_UNSPECIFIED", + "description": "- ORDER_NONE_UNSPECIFIED: zero-value for channel ordering\n - ORDER_UNORDERED: packets can be delivered in any order, which may differ from the order in\nwhich they were sent.\n - ORDER_ORDERED: packets are delivered exactly in the order which they were sent" + }, + "counterparty": { + "title": "counterparty channel end", + "type": "object", + "properties": { + "port_id": { + "type": "string", + "description": "port on the counterparty chain which owns the other end of the channel." + }, + "channel_id": { + "type": "string", + "title": "channel end on the counterparty chain" + } + } + }, + "connection_hops": { + "type": "array", + "items": { + "type": "string" + }, + "title": "list of connection identifiers, in order, along which packets sent on this\nchannel will travel" + }, + "version": { + "type": "string", + "title": "opaque channel version, which is agreed upon during the handshake" + }, + "port_id": { + "type": "string", + "title": "port identifier" + }, + "channel_id": { + "type": "string", + "title": "channel identifier" + } + }, + "description": "IdentifiedChannel defines a channel with additional port and channel\nidentifier fields." + }, + "description": "list of stored channels of the chain." + }, + "pagination": { + "title": "pagination response", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest.\n\n message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }" + }, + "height": { + "type": "string", + "format": "int64", + "title": "query block height" + } + }, + "description": "QueryChannelsResponse is the response type for the Query/Channels RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}": { + "get": { + "summary": "Channel queries an IBC Channel.", + "operationId": "Channel", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "channel": { + "title": "channel associated with the request identifiers", + "type": "object", + "properties": { + "state": { + "title": "current state of the channel end", + "type": "string", + "enum": [ + "STATE_UNINITIALIZED_UNSPECIFIED", + "STATE_INIT", + "STATE_TRYOPEN", + "STATE_OPEN", + "STATE_CLOSED" + ], + "default": "STATE_UNINITIALIZED_UNSPECIFIED", + "description": "State defines if a channel is in one of the following states:\nCLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.\n\n - STATE_UNINITIALIZED_UNSPECIFIED: Default State\n - STATE_INIT: A channel has just started the opening handshake.\n - STATE_TRYOPEN: A channel has acknowledged the handshake step on the counterparty chain.\n - STATE_OPEN: A channel has completed the handshake. Open channels are\nready to send and receive packets.\n - STATE_CLOSED: A channel has been closed and can no longer be used to send or receive\npackets." + }, + "ordering": { + "title": "whether the channel is ordered or unordered", + "type": "string", + "enum": [ + "ORDER_NONE_UNSPECIFIED", + "ORDER_UNORDERED", + "ORDER_ORDERED" + ], + "default": "ORDER_NONE_UNSPECIFIED", + "description": "- ORDER_NONE_UNSPECIFIED: zero-value for channel ordering\n - ORDER_UNORDERED: packets can be delivered in any order, which may differ from the order in\nwhich they were sent.\n - ORDER_ORDERED: packets are delivered exactly in the order which they were sent" + }, + "counterparty": { + "title": "counterparty channel end", + "type": "object", + "properties": { + "port_id": { + "type": "string", + "description": "port on the counterparty chain which owns the other end of the channel." + }, + "channel_id": { + "type": "string", + "title": "channel end on the counterparty chain" + } + } + }, + "connection_hops": { + "type": "array", + "items": { + "type": "string" + }, + "title": "list of connection identifiers, in order, along which packets sent on this\nchannel will travel" + }, + "version": { + "type": "string", + "title": "opaque channel version, which is agreed upon during the handshake" + } + }, + "description": "Channel defines pipeline for exactly-once packet delivery between specific\nmodules on separate blockchains, which has at least one end capable of\nsending packets and one end capable of receiving packets." + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "description": "QueryChannelResponse is the response type for the Query/Channel RPC method.\nBesides the Channel end, it includes a proof and the height from which the\nproof was retrieved." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/client_state": { + "get": { + "summary": "ChannelClientState queries for the client state for the channel associated\nwith the provided channel identifiers.", + "operationId": "ChannelClientState", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "identified_client_state": { + "title": "client state associated with the channel", + "type": "object", + "properties": { + "client_id": { + "type": "string", + "title": "client identifier" + }, + "client_state": { + "title": "client state", + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + }, + "description": "IdentifiedClientState defines a client state with additional client identifier field." + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryChannelClientStateResponse is the Response type for the\nQuery/QueryChannelClientState RPC method" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/consensus_state/{height}": { + "get": { + "summary": "ChannelConsensusState queries for the consensus state for the channel\nassociated with the provided channel identifiers.", + "operationId": "ChannelConsensusState", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "consensus_state": { + "title": "consensus state associated with the channel", + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "client_id": { + "type": "string", + "title": "client ID associated with the consensus state" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryChannelClientStateResponse is the Response type for the\nQuery/QueryChannelClientState RPC method" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "height", + "description": "height of the consensus state", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/next_sequence": { + "get": { + "summary": "NextSequenceReceive returns the next receive sequence for a given channel.", + "operationId": "NextSequenceReceive", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "next_sequence_receive": { + "type": "string", + "format": "uint64", + "title": "next sequence receive number" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QuerySequenceResponse is the request type for the\nQuery/QueryNextSequenceReceiveResponse RPC method" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_acks/{sequence}": { + "get": { + "summary": "PacketAcknowledgement queries a stored packet acknowledgement hash.", + "operationId": "PacketAcknowledgement", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "acknowledgement": { + "type": "string", + "format": "byte", + "title": "packet associated with the request fields" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryPacketAcknowledgementResponse defines the client query response for a\npacket which also includes a proof, its path and the height form which the\nproof was retrieved" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "sequence", + "description": "packet sequence", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments": { + "get": { + "summary": "PacketCommitments returns the all the packet commitments hashes associated\nwith a channel.", + "operationId": "PacketCommitments", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "commitments": { + "type": "array", + "items": { + "type": "object", + "properties": { + "port_id": { + "type": "string", + "description": "channel port identifier." + }, + "channel_id": { + "type": "string", + "description": "channel unique identifier." + }, + "sequence": { + "type": "string", + "format": "uint64", + "description": "packet sequence." + }, + "hash": { + "type": "string", + "format": "byte", + "description": "packet commitment hash." + } + }, + "description": "PacketAckCommitment defines the genesis type necessary to retrieve and store\nacknowlegements." + } + }, + "pagination": { + "title": "pagination response", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest.\n\n message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }" + }, + "height": { + "type": "string", + "format": "int64", + "title": "query block height" + } + }, + "title": "QueryPacketCommitmentsResponse is the request type for the\nQuery/QueryPacketCommitments RPC method" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/{packet_commitment_sequences}/packet_acks/{acknowledgements}/unrelayed_packets": { + "get": { + "summary": "UnrelayedPackets returns all the unrelayed IBC packets associated with a\nchannel and sequences.", + "operationId": "UnrelayedPackets", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "sequences": { + "type": "array", + "items": { + "type": "string", + "format": "uint64" + }, + "title": "list of unrelayed packet sequences" + }, + "height": { + "type": "string", + "format": "int64", + "title": "query block height" + } + }, + "title": "QueryUnrelayedPacketsResponse is the request type for the\nQuery/UnrelayedPacketCommitments RPC method" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "packet_commitment_sequences", + "description": "list of packet sequences", + "in": "path", + "required": true, + "type": "array", + "items": { + "type": "string", + "format": "uint64" + }, + "collectionFormat": "csv", + "minItems": 1 + }, + { + "name": "acknowledgements", + "description": "flag indicating if the return value is packet commitments or\nacknowledgements", + "in": "path", + "required": true, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/channels/{channel_id}/ports/{port_id}/packet_commitments/{sequence}": { + "get": { + "summary": "PacketCommitment queries a stored packet commitment hash.", + "operationId": "PacketCommitment", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "commitment": { + "type": "string", + "format": "byte", + "title": "packet associated with the request fields" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryPacketCommitmentResponse defines the client query response for a packet\nwhich also includes a proof, its path and the height form which the proof was\nretrieved" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "channel_id", + "description": "channel unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "port_id", + "description": "port unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "sequence", + "description": "packet sequence", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/channel/v1beta1/connections/{connection}/channels": { + "get": { + "summary": "ConnectionChannels queries all the channels associated with a connection\nend.", + "operationId": "ConnectionChannels", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "channels": { + "type": "array", + "items": { + "type": "object", + "properties": { + "state": { + "title": "current state of the channel end", + "type": "string", + "enum": [ + "STATE_UNINITIALIZED_UNSPECIFIED", + "STATE_INIT", + "STATE_TRYOPEN", + "STATE_OPEN", + "STATE_CLOSED" + ], + "default": "STATE_UNINITIALIZED_UNSPECIFIED", + "description": "State defines if a channel is in one of the following states:\nCLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.\n\n - STATE_UNINITIALIZED_UNSPECIFIED: Default State\n - STATE_INIT: A channel has just started the opening handshake.\n - STATE_TRYOPEN: A channel has acknowledged the handshake step on the counterparty chain.\n - STATE_OPEN: A channel has completed the handshake. Open channels are\nready to send and receive packets.\n - STATE_CLOSED: A channel has been closed and can no longer be used to send or receive\npackets." + }, + "ordering": { + "title": "whether the channel is ordered or unordered", + "type": "string", + "enum": [ + "ORDER_NONE_UNSPECIFIED", + "ORDER_UNORDERED", + "ORDER_ORDERED" + ], + "default": "ORDER_NONE_UNSPECIFIED", + "description": "- ORDER_NONE_UNSPECIFIED: zero-value for channel ordering\n - ORDER_UNORDERED: packets can be delivered in any order, which may differ from the order in\nwhich they were sent.\n - ORDER_ORDERED: packets are delivered exactly in the order which they were sent" + }, + "counterparty": { + "title": "counterparty channel end", + "type": "object", + "properties": { + "port_id": { + "type": "string", + "description": "port on the counterparty chain which owns the other end of the channel." + }, + "channel_id": { + "type": "string", + "title": "channel end on the counterparty chain" + } + } + }, + "connection_hops": { + "type": "array", + "items": { + "type": "string" + }, + "title": "list of connection identifiers, in order, along which packets sent on this\nchannel will travel" + }, + "version": { + "type": "string", + "title": "opaque channel version, which is agreed upon during the handshake" + }, + "port_id": { + "type": "string", + "title": "port identifier" + }, + "channel_id": { + "type": "string", + "title": "channel identifier" + } + }, + "description": "IdentifiedChannel defines a channel with additional port and channel\nidentifier fields." + }, + "description": "list of channels associated with a connection." + }, + "pagination": { + "title": "pagination response", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest.\n\n message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }" + }, + "height": { + "type": "string", + "format": "int64", + "title": "query block height" + } + }, + "title": "QueryConnectionChannelsResponse is the Response type for the\nQuery/QueryConnectionChannels RPC method" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "connection", + "description": "connection unique identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/client/v1beta1/client_states": { + "get": { + "summary": "ClientStates queries all the IBC light clients of a chain.", + "operationId": "ClientStates", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "client_states": { + "type": "array", + "items": { + "type": "object", + "properties": { + "client_id": { + "type": "string", + "title": "client identifier" + }, + "client_state": { + "title": "client state", + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + }, + "description": "IdentifiedClientState defines a client state with additional client identifier field." + }, + "description": "list of stored ClientStates of the chain." + }, + "pagination": { + "title": "pagination response", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest.\n\n message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }" + } + }, + "description": "QueryClientStatesResponse is the response type for the Query/ClientStates RPC\nmethod." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/client/v1beta1/client_states/{client_id}": { + "get": { + "summary": "ClientState queries an IBC light client.", + "operationId": "ClientState", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "client_state": { + "title": "client state associated with the request identifier", + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "description": "QueryClientStateResponse is the response type for the Query/ClientState RPC\nmethod. Besides the client state, it includes a proof and the height from\nwhich the proof was retrieved." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "client_id", + "description": "client state unique identifier", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/client/v1beta1/consensus_states/{client_id}": { + "get": { + "summary": "ConsensusStates queries all the consensus state associated with a given client.", + "operationId": "ConsensusStates", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "consensus_states": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "title": "consensus states associated with the identifier" + }, + "pagination": { + "title": "pagination response", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest.\n\n message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }" + } + }, + "title": "QueryConsensusStatesResponse is the response type for the Query/ConsensusStates RPC method" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "client_id", + "description": "client identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/client/v1beta1/consensus_states/{client_id}/{height}": { + "get": { + "summary": "ConsensusState queries a consensus state associated with a client state at a given height.", + "operationId": "ConsensusState", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "consensus_state": { + "title": "consensus state associated with the client identifier at the given height", + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryConsensusStateResponse is the response type for the Query/ConsensusState RPC method" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "client_id", + "description": "client identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "height", + "description": "consensus state height", + "in": "path", + "required": true, + "type": "string", + "format": "uint64" + }, + { + "name": "latest_height", + "description": "latest_height overrrides the height field and queries the latest stored ConsensusState.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/connection/v1beta1/client_connections/{client_id}": { + "get": { + "summary": "ClientConnections queries the connection paths associated with a client\nstate.", + "operationId": "ClientConnections", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "connection_paths": { + "type": "array", + "items": { + "type": "string" + }, + "description": "slice of all the connection paths associated with a client." + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was generated" + } + }, + "title": "QueryClientConnectionsResponse is the response type for the\nQuery/ClientConnections RPC method" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "client_id", + "description": "client identifier associated with a connection", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/connection/v1beta1/connections": { + "get": { + "summary": "Connections queries all the IBC connections of a chain.", + "operationId": "Connections", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "connections": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "string", + "description": "connection identifier." + }, + "client_id": { + "type": "string", + "description": "client associated with this connection." + }, + "versions": { + "type": "array", + "items": { + "type": "string" + }, + "title": "IBC version which can be utilised to determine encodings or protocols for\nchannels or packets utilising this connection" + }, + "state": { + "description": "current state of the connection end.", + "type": "string", + "enum": [ + "STATE_UNINITIALIZED_UNSPECIFIED", + "STATE_INIT", + "STATE_TRYOPEN", + "STATE_OPEN" + ], + "default": "STATE_UNINITIALIZED_UNSPECIFIED" + }, + "counterparty": { + "description": "counterparty chain associated with this connection.", + "type": "object", + "properties": { + "client_id": { + "type": "string", + "description": "identifies the client on the counterparty chain associated with a given\nconnection." + }, + "connection_id": { + "type": "string", + "description": "identifies the connection end on the counterparty chain associated with a\ngiven connection." + }, + "prefix": { + "title": "commitment merkle prefix of the counterparty chain", + "type": "object", + "properties": { + "key_prefix": { + "type": "string", + "format": "byte" + } + } + } + } + } + }, + "description": "IdentifiedConnection defines a connection with additional connection\nidentifier field." + }, + "description": "list of stored connections of the chain." + }, + "pagination": { + "title": "pagination response", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest.\n\n message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }" + }, + "height": { + "type": "string", + "format": "int64", + "title": "query block height" + } + }, + "description": "QueryConnectionsResponse is the response type for the Query/Connections RPC\nmethod." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/connection/v1beta1/connections/{connection_id}": { + "get": { + "summary": "Connection queries an IBC connection end.", + "operationId": "Connection", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "connection": { + "title": "connection associated with the request identifier", + "type": "object", + "properties": { + "client_id": { + "type": "string", + "description": "client associated with this connection." + }, + "versions": { + "type": "array", + "items": { + "type": "string" + }, + "title": "IBC version which can be utilised to determine encodings or protocols for\nchannels or packets utilising this connection" + }, + "state": { + "description": "current state of the connection end.", + "type": "string", + "enum": [ + "STATE_UNINITIALIZED_UNSPECIFIED", + "STATE_INIT", + "STATE_TRYOPEN", + "STATE_OPEN" + ], + "default": "STATE_UNINITIALIZED_UNSPECIFIED" + }, + "counterparty": { + "description": "counterparty chain associated with this connection.", + "type": "object", + "properties": { + "client_id": { + "type": "string", + "description": "identifies the client on the counterparty chain associated with a given\nconnection." + }, + "connection_id": { + "type": "string", + "description": "identifies the connection end on the counterparty chain associated with a\ngiven connection." + }, + "prefix": { + "title": "commitment merkle prefix of the counterparty chain", + "type": "object", + "properties": { + "key_prefix": { + "type": "string", + "format": "byte" + } + } + } + } + } + }, + "description": "ConnectionEnd defines a stateful object on a chain connected to another\nseparate one. NOTE: there must only be 2 defined ConnectionEnds to establish\na connection between two chains." + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "description": "QueryConnectionResponse is the response type for the Query/Connection RPC\nmethod. Besides the connection end, it includes a proof and the height from\nwhich the proof was retrieved." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "connection_id", + "description": "connection unique identifier", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/connection/v1beta1/connections/{connection_id}/client_state": { + "get": { + "summary": "ConnectionClientState queries the client state associated with the\nconnection.", + "operationId": "ConnectionClientState", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "identified_client_state": { + "title": "client state associated with the channel", + "type": "object", + "properties": { + "client_id": { + "type": "string", + "title": "client identifier" + }, + "client_state": { + "title": "client state", + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + }, + "description": "IdentifiedClientState defines a client state with additional client identifier field." + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryConnectionClientStateResponse is the response type for the\nQuery/ConnectionClientState RPC method" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "connection_id", + "description": "connection identifier", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc/connection/v1beta1/connections/{connection_id}/consensus_state": { + "get": { + "summary": "ConnectionConsensusState queries the consensus state associated with the\nconnection.", + "operationId": "ConnectionConsensusState", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "consensus_state": { + "title": "consensus state associated with the channel", + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "client_id": { + "type": "string", + "title": "client ID associated with the consensus state" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryConnectionConsensusStateResponse is the response type for the\nQuery/ConnectionConsensusState RPC method" + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + } + } + } + } + }, + "parameters": [ + { + "name": "connection_id", + "description": "connection identifier", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "height", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc_transfer/v1beta1/denom_traces": { + "get": { + "summary": "DenomTraces queries all denomination traces.", + "operationId": "DenomTraces", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "denom_traces": { + "type": "array", + "items": { + "type": "object", + "properties": { + "path": { + "type": "string", + "description": "path defines the chain of port/channel identifiers used for tracing the source of the fungible\ntoken." + }, + "base_denom": { + "type": "string", + "description": "base denomination of the relayed fungible token." + } + }, + "description": "DenomTrace contains the base denomination for ICS20 fungible tokens and the source tracing\ninformation path." + }, + "description": "denom_traces returns all denominations trace information." + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + } + } + }, + "description": "QueryConnectionsResponse is the response type for the Query/DenomTraces RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "pagination.key", + "description": "key is a value returned in PageResponse.next_key to begin\nquerying the next page most efficiently. Only one of offset or key\nshould be set.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "pagination.offset", + "description": "offset is a numeric offset that can be used when key is unavailable.\nIt is less efficient than using key. Only one of offset or key should\nbe set.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.limit", + "description": "limit is the total number of results to be returned in the result page.\nIf left empty it will default to a value to be set by each app.", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "pagination.count_total", + "description": "count_total is set to true to indicate that the result set should include\na count of the total number of items available for pagination in UIs. count_total\nis only respected when offset is used. It is ignored when key is set.", + "in": "query", + "required": false, + "type": "boolean", + "format": "boolean" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc_transfer/v1beta1/denom_traces/{hash}": { + "get": { + "summary": "DenomTrace queries a denomination trace information.", + "operationId": "DenomTrace", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "denom_trace": { + "description": "denom_trace returns the requested denomination trace information.", + "type": "object", + "properties": { + "path": { + "type": "string", + "description": "path defines the chain of port/channel identifiers used for tracing the source of the fungible\ntoken." + }, + "base_denom": { + "type": "string", + "description": "base denomination of the relayed fungible token." + } + } + } + }, + "description": "QueryDenomTraceResponse is the response type for the Query/DenomTrace RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "parameters": [ + { + "name": "hash", + "description": "hash (in hex format) of the denomination trace information.", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "Query" + ] + } + }, + "/ibc_transfer/v1beta1/params": { + "get": { + "summary": "Params queries all parameters of the ibc-transfer module.", + "operationId": "IBCTransferParams", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "type": "object", + "properties": { + "params": { + "description": "params defines the parameters of the module.", + "type": "object", + "properties": { + "send_enabled": { + "type": "boolean", + "format": "boolean", + "description": "send_enabled enables or disables all cross-chain token transfers from this chain." + }, + "receive_enabled": { + "type": "boolean", + "format": "boolean", + "description": "receive_enabled enables or disables all cross-chain token transfers to this chain." + } + } + } + }, + "description": "QueryParamsResponse is the response type for the Query/Params RPC method." + } + }, + "default": { + "description": "An unexpected error response", + "schema": { + "type": "object", + "properties": { + "error": { + "type": "string" + }, + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type_url": { + "type": "string" + }, + "value": { + "type": "string", + "format": "byte" + } + } + } + } + } + } + } + }, + "tags": [ + "Query" + ] + } } }, "definitions": { @@ -7416,126 +10042,509 @@ }, "description": "DelegationResponse is equivalent to Delegation except that it contains a balance\nin addition to shares which is more suitable for client responses." }, - "cosmos.staking.v1beta1.Description": { + "cosmos.staking.v1beta1.Description": { + "type": "object", + "properties": { + "moniker": { + "type": "string" + }, + "identity": { + "type": "string" + }, + "website": { + "type": "string" + }, + "security_contact": { + "type": "string" + }, + "details": { + "type": "string" + } + }, + "description": "Description defines a validator description." + }, + "cosmos.staking.v1beta1.HistoricalInfo": { + "type": "object", + "properties": { + "header": { + "type": "object", + "properties": { + "version": { + "title": "basic block info", + "type": "object", + "properties": { + "block": { + "type": "string", + "format": "uint64" + }, + "app": { + "type": "string", + "format": "uint64" + } + }, + "description": "Consensus captures the consensus rules for processing a block in the blockchain,\nincluding all blockchain data structures and the rules of the application's\nstate transition machine." + }, + "chain_id": { + "type": "string" + }, + "height": { + "type": "string", + "format": "int64" + }, + "time": { + "type": "string", + "format": "date-time" + }, + "last_block_id": { + "title": "prev block info", + "type": "object", + "properties": { + "hash": { + "type": "string", + "format": "byte" + }, + "part_set_header": { + "type": "object", + "properties": { + "total": { + "type": "integer", + "format": "int64" + }, + "hash": { + "type": "string", + "format": "byte" + } + }, + "title": "PartsetHeader" + } + } + }, + "last_commit_hash": { + "type": "string", + "format": "byte", + "title": "hashes of block data" + }, + "data_hash": { + "type": "string", + "format": "byte" + }, + "validators_hash": { + "type": "string", + "format": "byte", + "title": "hashes from the app output from the prev block" + }, + "next_validators_hash": { + "type": "string", + "format": "byte" + }, + "consensus_hash": { + "type": "string", + "format": "byte" + }, + "app_hash": { + "type": "string", + "format": "byte" + }, + "last_results_hash": { + "type": "string", + "format": "byte" + }, + "evidence_hash": { + "type": "string", + "format": "byte", + "title": "consensus info" + }, + "proposer_address": { + "type": "string", + "format": "byte" + } + }, + "description": "Header defines the structure of a Tendermint block header." + }, + "valset": { + "type": "array", + "items": { + "type": "object", + "properties": { + "operator_address": { + "type": "string", + "format": "byte" + }, + "consensus_pubkey": { + "type": "string" + }, + "jailed": { + "type": "boolean", + "format": "boolean" + }, + "status": { + "type": "integer", + "format": "int32" + }, + "tokens": { + "type": "string" + }, + "delegator_shares": { + "type": "string" + }, + "description": { + "type": "object", + "properties": { + "moniker": { + "type": "string" + }, + "identity": { + "type": "string" + }, + "website": { + "type": "string" + }, + "security_contact": { + "type": "string" + }, + "details": { + "type": "string" + } + }, + "description": "Description defines a validator description." + }, + "unbonding_height": { + "type": "string", + "format": "int64" + }, + "unbonding_time": { + "type": "string", + "format": "date-time" + }, + "commission": { + "type": "object", + "properties": { + "commission_rates": { + "type": "object", + "properties": { + "rate": { + "type": "string" + }, + "max_rate": { + "type": "string" + }, + "max_change_rate": { + "type": "string" + } + }, + "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + }, + "update_time": { + "type": "string", + "format": "date-time" + } + }, + "description": "Commission defines commission parameters for a given validator." + }, + "min_self_delegation": { + "type": "string" + } + }, + "description": "Validator defines a validator, together with the total amount of the Validator's\nbond shares and their exchange rate to coins.\nSlashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." + } + } + }, + "description": "HistoricalInfo contains header and validator information for a given block. It is stored\nas part of staking module's state, which persists the `n` most recent HistoricalInfo\n(`n` is set by the staking module's `historical_entries` parameter)." + }, + "cosmos.staking.v1beta1.Params": { "type": "object", "properties": { - "moniker": { + "unbonding_time": { "type": "string" }, - "identity": { - "type": "string" + "max_validators": { + "type": "integer", + "format": "int64" }, - "website": { - "type": "string" + "max_entries": { + "type": "integer", + "format": "int64" }, - "security_contact": { + "historical_entries": { + "type": "integer", + "format": "int64" + }, + "bond_denom": { + "type": "string" + } + }, + "description": "Params defines the parameters for the staking module." + }, + "cosmos.staking.v1beta1.Pool": { + "type": "object", + "properties": { + "not_bonded_tokens": { "type": "string" }, - "details": { + "bonded_tokens": { "type": "string" } }, - "description": "Description defines a validator description." + "description": "Pool is used for tracking bonded and not-bonded token supply of the bond denomination." }, - "cosmos.staking.v1beta1.HistoricalInfo": { + "cosmos.staking.v1beta1.QueryDelegationResponse": { "type": "object", "properties": { - "header": { + "delegation_response": { + "description": "delegation_responses defines the delegation info of a delegation.", "type": "object", "properties": { - "version": { - "title": "basic block info", + "delegation": { "type": "object", "properties": { - "block": { + "delegator_address": { "type": "string", - "format": "uint64" + "format": "byte" }, - "app": { + "validator_address": { "type": "string", - "format": "uint64" + "format": "byte" + }, + "shares": { + "type": "string" } }, - "description": "Consensus captures the consensus rules for processing a block in the blockchain,\nincluding all blockchain data structures and the rules of the application's\nstate transition machine." + "description": "Delegation represents the bond with tokens held by an account. It is\nowned by one delegator, and is associated with the voting power of one\nvalidator." }, - "chain_id": { - "type": "string" + "balance": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + } + } + } + }, + "description": "QueryDelegationResponse is response type for the Query/Delegation RPC method." + }, + "cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse": { + "type": "object", + "properties": { + "delegation_responses": { + "type": "array", + "items": { + "type": "object", + "properties": { + "delegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "shares": { + "type": "string" + } + }, + "description": "Delegation represents the bond with tokens held by an account. It is\nowned by one delegator, and is associated with the voting power of one\nvalidator." + }, + "balance": { + "type": "object", + "properties": { + "denom": { + "type": "string" + }, + "amount": { + "type": "string" + } + }, + "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + } }, - "height": { + "description": "DelegationResponse is equivalent to Delegation except that it contains a balance\nin addition to shares which is more suitable for client responses." + }, + "description": "delegation_responses defines all the delegations' info of a delegator." + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { "type": "string", - "format": "int64" + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" }, - "time": { + "total": { "type": "string", - "format": "date-time" - }, - "last_block_id": { - "title": "prev block info", - "type": "object", - "properties": { - "hash": { - "type": "string", - "format": "byte" - }, - "part_set_header": { + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + } + } + }, + "description": "QueryDelegatorDelegationsResponse is response type for the Query/DelegatorDelegations RPC method." + }, + "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse": { + "type": "object", + "properties": { + "unbonding_responses": { + "type": "array", + "items": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "entries": { + "type": "array", + "items": { "type": "object", "properties": { - "total": { - "type": "integer", + "creation_height": { + "type": "string", "format": "int64" }, - "hash": { + "completion_time": { "type": "string", - "format": "byte" + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "balance": { + "type": "string" } }, - "title": "PartsetHeader" + "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." } } }, - "last_commit_hash": { + "description": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list." + } + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { "type": "string", "format": "byte", - "title": "hashes of block data" + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" }, - "data_hash": { + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + } + } + }, + "description": "QueryUnbondingDelegatorDelegationsResponse is response type for the Query/UnbondingDelegatorDelegations RPC method." + }, + "cosmos.staking.v1beta1.QueryDelegatorValidatorResponse": { + "type": "object", + "properties": { + "validator": { + "description": "validator defines the the validator info.", + "type": "object", + "properties": { + "operator_address": { "type": "string", "format": "byte" }, - "validators_hash": { - "type": "string", - "format": "byte", - "title": "hashes from the app output from the prev block" + "consensus_pubkey": { + "type": "string" }, - "next_validators_hash": { - "type": "string", - "format": "byte" + "jailed": { + "type": "boolean", + "format": "boolean" }, - "consensus_hash": { - "type": "string", - "format": "byte" + "status": { + "type": "integer", + "format": "int32" }, - "app_hash": { - "type": "string", - "format": "byte" + "tokens": { + "type": "string" + }, + "delegator_shares": { + "type": "string" + }, + "description": { + "type": "object", + "properties": { + "moniker": { + "type": "string" + }, + "identity": { + "type": "string" + }, + "website": { + "type": "string" + }, + "security_contact": { + "type": "string" + }, + "details": { + "type": "string" + } + }, + "description": "Description defines a validator description." }, - "last_results_hash": { + "unbonding_height": { "type": "string", - "format": "byte" + "format": "int64" }, - "evidence_hash": { + "unbonding_time": { "type": "string", - "format": "byte", - "title": "consensus info" + "format": "date-time" }, - "proposer_address": { - "type": "string", - "format": "byte" + "commission": { + "type": "object", + "properties": { + "commission_rates": { + "type": "object", + "properties": { + "rate": { + "type": "string" + }, + "max_rate": { + "type": "string" + }, + "max_change_rate": { + "type": "string" + } + }, + "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + }, + "update_time": { + "type": "string", + "format": "date-time" + } + }, + "description": "Commission defines commission parameters for a given validator." + }, + "min_self_delegation": { + "type": "string" } - }, - "description": "Header defines the structure of a Tendermint block header." - }, - "valset": { + } + } + }, + "description": "QueryDelegatorValidatorResponse response type for the Query/DelegatorValidator RPC method." + }, + "cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse": { + "type": "object", + "properties": { + "validators": { "type": "array", "items": { "type": "object", @@ -7602,107 +10611,436 @@ "max_rate": { "type": "string" }, - "max_change_rate": { - "type": "string" + "max_change_rate": { + "type": "string" + } + }, + "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + }, + "update_time": { + "type": "string", + "format": "date-time" + } + }, + "description": "Commission defines commission parameters for a given validator." + }, + "min_self_delegation": { + "type": "string" + } + }, + "description": "Validator defines a validator, together with the total amount of the Validator's\nbond shares and their exchange rate to coins.\nSlashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." + }, + "description": "validators defines the the validators' info of a delegator." + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + } + } + }, + "description": "QueryDelegatorValidatorsResponse is response type for the Query/DelegatorValidators RPC method." + }, + "cosmos.staking.v1beta1.QueryHistoricalInfoResponse": { + "type": "object", + "properties": { + "hist": { + "description": "hist defines the historical info at the given height.", + "type": "object", + "properties": { + "header": { + "type": "object", + "properties": { + "version": { + "title": "basic block info", + "type": "object", + "properties": { + "block": { + "type": "string", + "format": "uint64" + }, + "app": { + "type": "string", + "format": "uint64" + } + }, + "description": "Consensus captures the consensus rules for processing a block in the blockchain,\nincluding all blockchain data structures and the rules of the application's\nstate transition machine." + }, + "chain_id": { + "type": "string" + }, + "height": { + "type": "string", + "format": "int64" + }, + "time": { + "type": "string", + "format": "date-time" + }, + "last_block_id": { + "title": "prev block info", + "type": "object", + "properties": { + "hash": { + "type": "string", + "format": "byte" + }, + "part_set_header": { + "type": "object", + "properties": { + "total": { + "type": "integer", + "format": "int64" + }, + "hash": { + "type": "string", + "format": "byte" + } + }, + "title": "PartsetHeader" + } + } + }, + "last_commit_hash": { + "type": "string", + "format": "byte", + "title": "hashes of block data" + }, + "data_hash": { + "type": "string", + "format": "byte" + }, + "validators_hash": { + "type": "string", + "format": "byte", + "title": "hashes from the app output from the prev block" + }, + "next_validators_hash": { + "type": "string", + "format": "byte" + }, + "consensus_hash": { + "type": "string", + "format": "byte" + }, + "app_hash": { + "type": "string", + "format": "byte" + }, + "last_results_hash": { + "type": "string", + "format": "byte" + }, + "evidence_hash": { + "type": "string", + "format": "byte", + "title": "consensus info" + }, + "proposer_address": { + "type": "string", + "format": "byte" + } + }, + "description": "Header defines the structure of a Tendermint block header." + }, + "valset": { + "type": "array", + "items": { + "type": "object", + "properties": { + "operator_address": { + "type": "string", + "format": "byte" + }, + "consensus_pubkey": { + "type": "string" + }, + "jailed": { + "type": "boolean", + "format": "boolean" + }, + "status": { + "type": "integer", + "format": "int32" + }, + "tokens": { + "type": "string" + }, + "delegator_shares": { + "type": "string" + }, + "description": { + "type": "object", + "properties": { + "moniker": { + "type": "string" + }, + "identity": { + "type": "string" + }, + "website": { + "type": "string" + }, + "security_contact": { + "type": "string" + }, + "details": { + "type": "string" + } + }, + "description": "Description defines a validator description." + }, + "unbonding_height": { + "type": "string", + "format": "int64" + }, + "unbonding_time": { + "type": "string", + "format": "date-time" + }, + "commission": { + "type": "object", + "properties": { + "commission_rates": { + "type": "object", + "properties": { + "rate": { + "type": "string" + }, + "max_rate": { + "type": "string" + }, + "max_change_rate": { + "type": "string" + } + }, + "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + }, + "update_time": { + "type": "string", + "format": "date-time" } }, - "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + "description": "Commission defines commission parameters for a given validator." }, - "update_time": { - "type": "string", - "format": "date-time" + "min_self_delegation": { + "type": "string" } }, - "description": "Commission defines commission parameters for a given validator." - }, - "min_self_delegation": { - "type": "string" + "description": "Validator defines a validator, together with the total amount of the Validator's\nbond shares and their exchange rate to coins.\nSlashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." } + } + } + } + }, + "description": "QueryHistoricalInfoResponse is response type for the Query/HistoricalInfo RPC method." + }, + "cosmos.staking.v1beta1.QueryParamsResponse": { + "type": "object", + "properties": { + "params": { + "description": "params holds all the parameters of this module.", + "type": "object", + "properties": { + "unbonding_time": { + "type": "string" }, - "description": "Validator defines a validator, together with the total amount of the Validator's\nbond shares and their exchange rate to coins.\nSlashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." + "max_validators": { + "type": "integer", + "format": "int64" + }, + "max_entries": { + "type": "integer", + "format": "int64" + }, + "historical_entries": { + "type": "integer", + "format": "int64" + }, + "bond_denom": { + "type": "string" + } } } }, - "description": "HistoricalInfo contains header and validator information for a given block. It is stored\nas part of staking module's state, which persists the `n` most recent HistoricalInfo\n(`n` is set by the staking module's `historical_entries` parameter)." + "description": "QueryParamsResponse is response type for the Query/Params RPC method." }, - "cosmos.staking.v1beta1.Params": { + "cosmos.staking.v1beta1.QueryPoolResponse": { "type": "object", "properties": { - "unbonding_time": { - "type": "string" - }, - "max_validators": { - "type": "integer", - "format": "int64" - }, - "max_entries": { - "type": "integer", - "format": "int64" - }, - "historical_entries": { - "type": "integer", - "format": "int64" - }, - "bond_denom": { - "type": "string" + "pool": { + "description": "pool defines the pool info.", + "type": "object", + "properties": { + "not_bonded_tokens": { + "type": "string" + }, + "bonded_tokens": { + "type": "string" + } + } } }, - "description": "Params defines the parameters for the staking module." + "description": "QueryPoolResponse is response type for the Query/Pool RPC method." }, - "cosmos.staking.v1beta1.Pool": { + "cosmos.staking.v1beta1.QueryRedelegationsResponse": { "type": "object", "properties": { - "not_bonded_tokens": { - "type": "string" + "redelegation_responses": { + "type": "array", + "items": { + "type": "object", + "properties": { + "redelegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_src_address": { + "type": "string", + "format": "byte" + }, + "validator_dst_address": { + "type": "string", + "format": "byte" + }, + "entries": { + "type": "array", + "items": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "shares_dst": { + "type": "string" + } + }, + "description": "RedelegationEntry defines a redelegation object with relevant metadata." + } + } + }, + "description": "Redelegation contains the list of a particular delegator's redelegating bonds\nfrom a particular source validator to a particular destination validator." + }, + "entries": { + "type": "array", + "items": { + "type": "object", + "properties": { + "redelegation_entry": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "shares_dst": { + "type": "string" + } + }, + "description": "RedelegationEntry defines a redelegation object with relevant metadata." + }, + "balance": { + "type": "string" + } + }, + "description": "RedelegationEntryResponse is equivalent to a RedelegationEntry except that it\ncontains a balance in addition to shares which is more suitable for client\nresponses." + } + } + }, + "description": "RedelegationResponse is equivalent to a Redelegation except that its entries\ncontain a balance in addition to shares which is more suitable for client\nresponses." + } }, - "bonded_tokens": { - "type": "string" + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + } } }, - "description": "Pool is used for tracking bonded and not-bonded token supply of the bond denomination." + "description": "QueryRedelegationsResponse is response type for the Query/Redelegations RPC method." }, - "cosmos.staking.v1beta1.QueryDelegationResponse": { + "cosmos.staking.v1beta1.QueryUnbondingDelegationResponse": { "type": "object", "properties": { - "delegation_response": { - "description": "delegation_responses defines the delegation info of a delegation.", + "unbond": { + "description": "unbond defines the unbonding information of a delegation.", "type": "object", "properties": { - "delegation": { - "type": "object", - "properties": { - "delegator_address": { - "type": "string", - "format": "byte" - }, - "validator_address": { - "type": "string", - "format": "byte" - }, - "shares": { - "type": "string" - } - }, - "description": "Delegation represents the bond with tokens held by an account. It is\nowned by one delegator, and is associated with the voting power of one\nvalidator." + "delegator_address": { + "type": "string", + "format": "byte" }, - "balance": { - "type": "object", - "properties": { - "denom": { - "type": "string" + "validator_address": { + "type": "string", + "format": "byte" + }, + "entries": { + "type": "array", + "items": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "balance": { + "type": "string" + } }, - "amount": { - "type": "string" - } - }, - "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." + "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." + } } } } }, - "description": "QueryDelegationResponse is response type for the Query/Delegation RPC method." + "description": "QueryDelegationResponse is response type for the Query/UnbondingDelegation RPC method." }, - "cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse": { + "cosmos.staking.v1beta1.QueryValidatorDelegationsResponse": { "type": "object", "properties": { "delegation_responses": { @@ -7741,69 +11079,6 @@ } }, "description": "DelegationResponse is equivalent to Delegation except that it contains a balance\nin addition to shares which is more suitable for client responses." - }, - "description": "delegation_responses defines all the delegations' info of a delegator." - }, - "pagination": { - "description": "pagination defines the pagination in the response.", - "type": "object", - "properties": { - "next_key": { - "type": "string", - "format": "byte", - "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" - }, - "total": { - "type": "string", - "format": "uint64", - "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" - } - } - } - }, - "description": "QueryDelegatorDelegationsResponse is response type for the Query/DelegatorDelegations RPC method." - }, - "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse": { - "type": "object", - "properties": { - "unbonding_responses": { - "type": "array", - "items": { - "type": "object", - "properties": { - "delegator_address": { - "type": "string", - "format": "byte" - }, - "validator_address": { - "type": "string", - "format": "byte" - }, - "entries": { - "type": "array", - "items": { - "type": "object", - "properties": { - "creation_height": { - "type": "string", - "format": "int64" - }, - "completion_time": { - "type": "string", - "format": "date-time" - }, - "initial_balance": { - "type": "string" - }, - "balance": { - "type": "string" - } - }, - "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." - } - } - }, - "description": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list." } }, "pagination": { @@ -7823,9 +11098,9 @@ } } }, - "description": "QueryUnbondingDelegatorDelegationsResponse is response type for the Query/UnbondingDelegatorDelegations RPC method." + "title": "QueryValidatorDelegationsResponse is response type for the Query/ValidatorDelegations RPC method" }, - "cosmos.staking.v1beta1.QueryDelegatorValidatorResponse": { + "cosmos.staking.v1beta1.QueryValidatorResponse": { "type": "object", "properties": { "validator": { @@ -7913,9 +11188,71 @@ } } }, - "description": "QueryDelegatorValidatorResponse response type for the Query/DelegatorValidator RPC method." + "title": "QueryValidatorResponse is response type for the Query/Validator RPC method" }, - "cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse": { + "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse": { + "type": "object", + "properties": { + "unbonding_responses": { + "type": "array", + "items": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "entries": { + "type": "array", + "items": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "balance": { + "type": "string" + } + }, + "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." + } + } + }, + "description": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list." + } + }, + "pagination": { + "description": "pagination defines the pagination in the response.", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + } + } + }, + "description": "QueryValidatorUnbondingDelegationsResponse is response type for the Query/ValidatorUnbondingDelegations RPC method." + }, + "cosmos.staking.v1beta1.QueryValidatorsResponse": { "type": "object", "properties": { "validators": { @@ -8004,7 +11341,7 @@ }, "description": "Validator defines a validator, together with the total amount of the Validator's\nbond shares and their exchange rate to coins.\nSlashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." }, - "description": "validators defines the the validators' info of a delegator." + "description": "validators contains all the queried validators." }, "pagination": { "description": "pagination defines the pagination in the response.", @@ -8023,592 +11360,932 @@ } } }, - "description": "QueryDelegatorValidatorsResponse is response type for the Query/DelegatorValidators RPC method." + "title": "QueryValidatorsResponse is response type for the Query/Validators RPC method" }, - "cosmos.staking.v1beta1.QueryHistoricalInfoResponse": { + "cosmos.staking.v1beta1.Redelegation": { "type": "object", "properties": { - "hist": { - "description": "hist defines the historical info at the given height.", - "type": "object", - "properties": { - "header": { - "type": "object", - "properties": { - "version": { - "title": "basic block info", - "type": "object", - "properties": { - "block": { - "type": "string", - "format": "uint64" - }, - "app": { - "type": "string", - "format": "uint64" - } - }, - "description": "Consensus captures the consensus rules for processing a block in the blockchain,\nincluding all blockchain data structures and the rules of the application's\nstate transition machine." - }, - "chain_id": { - "type": "string" - }, - "height": { - "type": "string", - "format": "int64" - }, - "time": { - "type": "string", - "format": "date-time" - }, - "last_block_id": { - "title": "prev block info", - "type": "object", - "properties": { - "hash": { - "type": "string", - "format": "byte" - }, - "part_set_header": { - "type": "object", - "properties": { - "total": { - "type": "integer", - "format": "int64" - }, - "hash": { - "type": "string", - "format": "byte" - } - }, - "title": "PartsetHeader" - } - } - }, - "last_commit_hash": { - "type": "string", - "format": "byte", - "title": "hashes of block data" - }, - "data_hash": { - "type": "string", - "format": "byte" - }, - "validators_hash": { - "type": "string", - "format": "byte", - "title": "hashes from the app output from the prev block" - }, - "next_validators_hash": { - "type": "string", - "format": "byte" - }, - "consensus_hash": { - "type": "string", - "format": "byte" - }, - "app_hash": { - "type": "string", - "format": "byte" - }, - "last_results_hash": { - "type": "string", - "format": "byte" - }, - "evidence_hash": { - "type": "string", - "format": "byte", - "title": "consensus info" - }, - "proposer_address": { - "type": "string", - "format": "byte" - } + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_src_address": { + "type": "string", + "format": "byte" + }, + "validator_dst_address": { + "type": "string", + "format": "byte" + }, + "entries": { + "type": "array", + "items": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" }, - "description": "Header defines the structure of a Tendermint block header." + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "shares_dst": { + "type": "string" + } }, - "valset": { + "description": "RedelegationEntry defines a redelegation object with relevant metadata." + } + } + }, + "description": "Redelegation contains the list of a particular delegator's redelegating bonds\nfrom a particular source validator to a particular destination validator." + }, + "cosmos.staking.v1beta1.RedelegationEntry": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "shares_dst": { + "type": "string" + } + }, + "description": "RedelegationEntry defines a redelegation object with relevant metadata." + }, + "cosmos.staking.v1beta1.RedelegationEntryResponse": { + "type": "object", + "properties": { + "redelegation_entry": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "shares_dst": { + "type": "string" + } + }, + "description": "RedelegationEntry defines a redelegation object with relevant metadata." + }, + "balance": { + "type": "string" + } + }, + "description": "RedelegationEntryResponse is equivalent to a RedelegationEntry except that it\ncontains a balance in addition to shares which is more suitable for client\nresponses." + }, + "cosmos.staking.v1beta1.RedelegationResponse": { + "type": "object", + "properties": { + "redelegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_src_address": { + "type": "string", + "format": "byte" + }, + "validator_dst_address": { + "type": "string", + "format": "byte" + }, + "entries": { "type": "array", "items": { "type": "object", "properties": { - "operator_address": { + "creation_height": { "type": "string", - "format": "byte" - }, - "consensus_pubkey": { - "type": "string" - }, - "jailed": { - "type": "boolean", - "format": "boolean" + "format": "int64" }, - "status": { - "type": "integer", - "format": "int32" + "completion_time": { + "type": "string", + "format": "date-time" }, - "tokens": { + "initial_balance": { "type": "string" }, - "delegator_shares": { + "shares_dst": { "type": "string" - }, - "description": { - "type": "object", - "properties": { - "moniker": { - "type": "string" - }, - "identity": { - "type": "string" - }, - "website": { - "type": "string" - }, - "security_contact": { - "type": "string" - }, - "details": { - "type": "string" - } - }, - "description": "Description defines a validator description." - }, - "unbonding_height": { + } + }, + "description": "RedelegationEntry defines a redelegation object with relevant metadata." + } + } + }, + "description": "Redelegation contains the list of a particular delegator's redelegating bonds\nfrom a particular source validator to a particular destination validator." + }, + "entries": { + "type": "array", + "items": { + "type": "object", + "properties": { + "redelegation_entry": { + "type": "object", + "properties": { + "creation_height": { "type": "string", "format": "int64" }, - "unbonding_time": { + "completion_time": { "type": "string", "format": "date-time" }, - "commission": { - "type": "object", - "properties": { - "commission_rates": { - "type": "object", - "properties": { - "rate": { - "type": "string" - }, - "max_rate": { - "type": "string" - }, - "max_change_rate": { - "type": "string" - } - }, - "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." - }, - "update_time": { - "type": "string", - "format": "date-time" - } - }, - "description": "Commission defines commission parameters for a given validator." + "initial_balance": { + "type": "string" }, - "min_self_delegation": { + "shares_dst": { "type": "string" } }, - "description": "Validator defines a validator, together with the total amount of the Validator's\nbond shares and their exchange rate to coins.\nSlashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." - } + "description": "RedelegationEntry defines a redelegation object with relevant metadata." + }, + "balance": { + "type": "string" + } + }, + "description": "RedelegationEntryResponse is equivalent to a RedelegationEntry except that it\ncontains a balance in addition to shares which is more suitable for client\nresponses." + } + } + }, + "description": "RedelegationResponse is equivalent to a Redelegation except that its entries\ncontain a balance in addition to shares which is more suitable for client\nresponses." + }, + "cosmos.staking.v1beta1.UnbondingDelegation": { + "type": "object", + "properties": { + "delegator_address": { + "type": "string", + "format": "byte" + }, + "validator_address": { + "type": "string", + "format": "byte" + }, + "entries": { + "type": "array", + "items": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "balance": { + "type": "string" + } + }, + "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." + } + } + }, + "description": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list." + }, + "cosmos.staking.v1beta1.UnbondingDelegationEntry": { + "type": "object", + "properties": { + "creation_height": { + "type": "string", + "format": "int64" + }, + "completion_time": { + "type": "string", + "format": "date-time" + }, + "initial_balance": { + "type": "string" + }, + "balance": { + "type": "string" + } + }, + "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." + }, + "cosmos.staking.v1beta1.Validator": { + "type": "object", + "properties": { + "operator_address": { + "type": "string", + "format": "byte" + }, + "consensus_pubkey": { + "type": "string" + }, + "jailed": { + "type": "boolean", + "format": "boolean" + }, + "status": { + "type": "integer", + "format": "int32" + }, + "tokens": { + "type": "string" + }, + "delegator_shares": { + "type": "string" + }, + "description": { + "type": "object", + "properties": { + "moniker": { + "type": "string" + }, + "identity": { + "type": "string" + }, + "website": { + "type": "string" + }, + "security_contact": { + "type": "string" + }, + "details": { + "type": "string" + } + }, + "description": "Description defines a validator description." + }, + "unbonding_height": { + "type": "string", + "format": "int64" + }, + "unbonding_time": { + "type": "string", + "format": "date-time" + }, + "commission": { + "type": "object", + "properties": { + "commission_rates": { + "type": "object", + "properties": { + "rate": { + "type": "string" + }, + "max_rate": { + "type": "string" + }, + "max_change_rate": { + "type": "string" + } + }, + "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + }, + "update_time": { + "type": "string", + "format": "date-time" } - } + }, + "description": "Commission defines commission parameters for a given validator." + }, + "min_self_delegation": { + "type": "string" } }, - "description": "QueryHistoricalInfoResponse is response type for the Query/HistoricalInfo RPC method." + "description": "Validator defines a validator, together with the total amount of the Validator's\nbond shares and their exchange rate to coins.\nSlashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." }, - "cosmos.staking.v1beta1.QueryParamsResponse": { + "tendermint.types.BlockID": { "type": "object", "properties": { - "params": { - "description": "params holds all the parameters of this module.", + "hash": { + "type": "string", + "format": "byte" + }, + "part_set_header": { "type": "object", "properties": { - "unbonding_time": { - "type": "string" - }, - "max_validators": { + "total": { "type": "integer", "format": "int64" }, - "max_entries": { - "type": "integer", - "format": "int64" + "hash": { + "type": "string", + "format": "byte" + } + }, + "title": "PartsetHeader" + } + }, + "title": "BlockID" + }, + "tendermint.types.Header": { + "type": "object", + "properties": { + "version": { + "title": "basic block info", + "type": "object", + "properties": { + "block": { + "type": "string", + "format": "uint64" }, - "historical_entries": { - "type": "integer", - "format": "int64" + "app": { + "type": "string", + "format": "uint64" + } + }, + "description": "Consensus captures the consensus rules for processing a block in the blockchain,\nincluding all blockchain data structures and the rules of the application's\nstate transition machine." + }, + "chain_id": { + "type": "string" + }, + "height": { + "type": "string", + "format": "int64" + }, + "time": { + "type": "string", + "format": "date-time" + }, + "last_block_id": { + "title": "prev block info", + "type": "object", + "properties": { + "hash": { + "type": "string", + "format": "byte" }, - "bond_denom": { - "type": "string" + "part_set_header": { + "type": "object", + "properties": { + "total": { + "type": "integer", + "format": "int64" + }, + "hash": { + "type": "string", + "format": "byte" + } + }, + "title": "PartsetHeader" } } + }, + "last_commit_hash": { + "type": "string", + "format": "byte", + "title": "hashes of block data" + }, + "data_hash": { + "type": "string", + "format": "byte" + }, + "validators_hash": { + "type": "string", + "format": "byte", + "title": "hashes from the app output from the prev block" + }, + "next_validators_hash": { + "type": "string", + "format": "byte" + }, + "consensus_hash": { + "type": "string", + "format": "byte" + }, + "app_hash": { + "type": "string", + "format": "byte" + }, + "last_results_hash": { + "type": "string", + "format": "byte" + }, + "evidence_hash": { + "type": "string", + "format": "byte", + "title": "consensus info" + }, + "proposer_address": { + "type": "string", + "format": "byte" + } + }, + "description": "Header defines the structure of a Tendermint block header." + }, + "tendermint.types.PartSetHeader": { + "type": "object", + "properties": { + "total": { + "type": "integer", + "format": "int64" + }, + "hash": { + "type": "string", + "format": "byte" + } + }, + "title": "PartsetHeader" + }, + "tendermint.version.Consensus": { + "type": "object", + "properties": { + "block": { + "type": "string", + "format": "uint64" + }, + "app": { + "type": "string", + "format": "uint64" + } + }, + "description": "Consensus captures the consensus rules for processing a block in the blockchain,\nincluding all blockchain data structures and the rules of the application's\nstate transition machine." + }, + "cosmos.upgrade.v1beta1.Plan": { + "type": "object", + "properties": { + "name": { + "type": "string", + "description": "Sets the name for the upgrade. This name will be used by the upgraded version of the software to apply any\nspecial \"on-upgrade\" commands during the first BeginBlock method after the upgrade is applied. It is also used\nto detect whether a software version can handle a given upgrade. If no upgrade handler with this name has been\nset in the software, it will be assumed that the software is out-of-date when the upgrade Time or Height\nis reached and the software will exit." + }, + "time": { + "type": "string", + "format": "date-time", + "description": "The time after which the upgrade must be performed.\nLeave set to its zero value to use a pre-defined Height instead." + }, + "height": { + "type": "string", + "format": "int64", + "description": "The height at which the upgrade must be performed.\nOnly used if Time is not set." + }, + "info": { + "type": "string", + "title": "Any application specific upgrade info to be included on-chain\nsuch as a git commit that validators could automatically upgrade to" + } + }, + "description": "Plan specifies information about a planned upgrade and when it should occur." + }, + "cosmos.upgrade.v1beta1.QueryAppliedPlanResponse": { + "type": "object", + "properties": { + "height": { + "type": "string", + "format": "int64", + "description": "height is the block height at which the plan was applied." } }, - "description": "QueryParamsResponse is response type for the Query/Params RPC method." + "description": "QueryAppliedPlanResponse is the response type for the Query/AppliedPlan RPC method." }, - "cosmos.staking.v1beta1.QueryPoolResponse": { + "cosmos.upgrade.v1beta1.QueryCurrentPlanResponse": { "type": "object", "properties": { - "pool": { - "description": "pool defines the pool info.", + "plan": { + "description": "plan is the current upgrade plan.", "type": "object", "properties": { - "not_bonded_tokens": { - "type": "string" + "name": { + "type": "string", + "description": "Sets the name for the upgrade. This name will be used by the upgraded version of the software to apply any\nspecial \"on-upgrade\" commands during the first BeginBlock method after the upgrade is applied. It is also used\nto detect whether a software version can handle a given upgrade. If no upgrade handler with this name has been\nset in the software, it will be assumed that the software is out-of-date when the upgrade Time or Height\nis reached and the software will exit." }, - "bonded_tokens": { - "type": "string" + "time": { + "type": "string", + "format": "date-time", + "description": "The time after which the upgrade must be performed.\nLeave set to its zero value to use a pre-defined Height instead." + }, + "height": { + "type": "string", + "format": "int64", + "description": "The height at which the upgrade must be performed.\nOnly used if Time is not set." + }, + "info": { + "type": "string", + "title": "Any application specific upgrade info to be included on-chain\nsuch as a git commit that validators could automatically upgrade to" } } } }, - "description": "QueryPoolResponse is response type for the Query/Pool RPC method." + "description": "QueryCurrentPlanResponse is the response type for the Query/CurrentPlan RPC method." }, - "cosmos.staking.v1beta1.QueryRedelegationsResponse": { + "ibc.channel.Channel": { "type": "object", "properties": { - "redelegation_responses": { - "type": "array", - "items": { - "type": "object", - "properties": { - "redelegation": { - "type": "object", - "properties": { - "delegator_address": { - "type": "string", - "format": "byte" - }, - "validator_src_address": { - "type": "string", - "format": "byte" - }, - "validator_dst_address": { - "type": "string", - "format": "byte" - }, - "entries": { - "type": "array", - "items": { - "type": "object", - "properties": { - "creation_height": { - "type": "string", - "format": "int64" - }, - "completion_time": { - "type": "string", - "format": "date-time" - }, - "initial_balance": { - "type": "string" - }, - "shares_dst": { - "type": "string" - } - }, - "description": "RedelegationEntry defines a redelegation object with relevant metadata." - } - } - }, - "description": "Redelegation contains the list of a particular delegator's redelegating bonds\nfrom a particular source validator to a particular destination validator." - }, - "entries": { - "type": "array", - "items": { - "type": "object", - "properties": { - "redelegation_entry": { - "type": "object", - "properties": { - "creation_height": { - "type": "string", - "format": "int64" - }, - "completion_time": { - "type": "string", - "format": "date-time" - }, - "initial_balance": { - "type": "string" - }, - "shares_dst": { - "type": "string" - } - }, - "description": "RedelegationEntry defines a redelegation object with relevant metadata." - }, - "balance": { - "type": "string" - } - }, - "description": "RedelegationEntryResponse is equivalent to a RedelegationEntry except that it\ncontains a balance in addition to shares which is more suitable for client\nresponses." - } - } - }, - "description": "RedelegationResponse is equivalent to a Redelegation except that its entries\ncontain a balance in addition to shares which is more suitable for client\nresponses." - } + "state": { + "title": "current state of the channel end", + "type": "string", + "enum": [ + "STATE_UNINITIALIZED_UNSPECIFIED", + "STATE_INIT", + "STATE_TRYOPEN", + "STATE_OPEN", + "STATE_CLOSED" + ], + "default": "STATE_UNINITIALIZED_UNSPECIFIED", + "description": "State defines if a channel is in one of the following states:\nCLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.\n\n - STATE_UNINITIALIZED_UNSPECIFIED: Default State\n - STATE_INIT: A channel has just started the opening handshake.\n - STATE_TRYOPEN: A channel has acknowledged the handshake step on the counterparty chain.\n - STATE_OPEN: A channel has completed the handshake. Open channels are\nready to send and receive packets.\n - STATE_CLOSED: A channel has been closed and can no longer be used to send or receive\npackets." }, - "pagination": { - "description": "pagination defines the pagination in the response.", + "ordering": { + "title": "whether the channel is ordered or unordered", + "type": "string", + "enum": [ + "ORDER_NONE_UNSPECIFIED", + "ORDER_UNORDERED", + "ORDER_ORDERED" + ], + "default": "ORDER_NONE_UNSPECIFIED", + "description": "- ORDER_NONE_UNSPECIFIED: zero-value for channel ordering\n - ORDER_UNORDERED: packets can be delivered in any order, which may differ from the order in\nwhich they were sent.\n - ORDER_ORDERED: packets are delivered exactly in the order which they were sent" + }, + "counterparty": { + "title": "counterparty channel end", "type": "object", "properties": { - "next_key": { + "port_id": { "type": "string", - "format": "byte", - "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + "description": "port on the counterparty chain which owns the other end of the channel." }, - "total": { + "channel_id": { "type": "string", - "format": "uint64", - "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + "title": "channel end on the counterparty chain" } } + }, + "connection_hops": { + "type": "array", + "items": { + "type": "string" + }, + "title": "list of connection identifiers, in order, along which packets sent on this\nchannel will travel" + }, + "version": { + "type": "string", + "title": "opaque channel version, which is agreed upon during the handshake" } }, - "description": "QueryRedelegationsResponse is response type for the Query/Redelegations RPC method." + "description": "Channel defines pipeline for exactly-once packet delivery between specific\nmodules on separate blockchains, which has at least one end capable of\nsending packets and one end capable of receiving packets." }, - "cosmos.staking.v1beta1.QueryUnbondingDelegationResponse": { + "ibc.channel.Counterparty": { "type": "object", "properties": { - "unbond": { - "description": "unbond defines the unbonding information of a delegation.", - "type": "object", - "properties": { - "delegator_address": { - "type": "string", - "format": "byte" - }, - "validator_address": { - "type": "string", - "format": "byte" - }, - "entries": { - "type": "array", - "items": { - "type": "object", - "properties": { - "creation_height": { - "type": "string", - "format": "int64" - }, - "completion_time": { - "type": "string", - "format": "date-time" - }, - "initial_balance": { - "type": "string" - }, - "balance": { - "type": "string" - } - }, - "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." - } - } - } + "port_id": { + "type": "string", + "description": "port on the counterparty chain which owns the other end of the channel." + }, + "channel_id": { + "type": "string", + "title": "channel end on the counterparty chain" } }, - "description": "QueryDelegationResponse is response type for the Query/UnbondingDelegation RPC method." + "title": "Counterparty defines a channel end counterparty" }, - "cosmos.staking.v1beta1.QueryValidatorDelegationsResponse": { + "ibc.channel.IdentifiedChannel": { "type": "object", "properties": { - "delegation_responses": { - "type": "array", - "items": { - "type": "object", - "properties": { - "delegation": { - "type": "object", - "properties": { - "delegator_address": { - "type": "string", - "format": "byte" - }, - "validator_address": { - "type": "string", - "format": "byte" - }, - "shares": { - "type": "string" - } - }, - "description": "Delegation represents the bond with tokens held by an account. It is\nowned by one delegator, and is associated with the voting power of one\nvalidator." - }, - "balance": { - "type": "object", - "properties": { - "denom": { - "type": "string" - }, - "amount": { - "type": "string" - } - }, - "description": "Coin defines a token with a denomination and an amount.\n\nNOTE: The amount field is an Int which implements the custom method\nsignatures required by gogoproto." - } - }, - "description": "DelegationResponse is equivalent to Delegation except that it contains a balance\nin addition to shares which is more suitable for client responses." - } + "state": { + "title": "current state of the channel end", + "type": "string", + "enum": [ + "STATE_UNINITIALIZED_UNSPECIFIED", + "STATE_INIT", + "STATE_TRYOPEN", + "STATE_OPEN", + "STATE_CLOSED" + ], + "default": "STATE_UNINITIALIZED_UNSPECIFIED", + "description": "State defines if a channel is in one of the following states:\nCLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.\n\n - STATE_UNINITIALIZED_UNSPECIFIED: Default State\n - STATE_INIT: A channel has just started the opening handshake.\n - STATE_TRYOPEN: A channel has acknowledged the handshake step on the counterparty chain.\n - STATE_OPEN: A channel has completed the handshake. Open channels are\nready to send and receive packets.\n - STATE_CLOSED: A channel has been closed and can no longer be used to send or receive\npackets." }, - "pagination": { - "description": "pagination defines the pagination in the response.", + "ordering": { + "title": "whether the channel is ordered or unordered", + "type": "string", + "enum": [ + "ORDER_NONE_UNSPECIFIED", + "ORDER_UNORDERED", + "ORDER_ORDERED" + ], + "default": "ORDER_NONE_UNSPECIFIED", + "description": "- ORDER_NONE_UNSPECIFIED: zero-value for channel ordering\n - ORDER_UNORDERED: packets can be delivered in any order, which may differ from the order in\nwhich they were sent.\n - ORDER_ORDERED: packets are delivered exactly in the order which they were sent" + }, + "counterparty": { + "title": "counterparty channel end", "type": "object", "properties": { - "next_key": { + "port_id": { "type": "string", - "format": "byte", - "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + "description": "port on the counterparty chain which owns the other end of the channel." }, - "total": { + "channel_id": { "type": "string", - "format": "uint64", - "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + "title": "channel end on the counterparty chain" } } + }, + "connection_hops": { + "type": "array", + "items": { + "type": "string" + }, + "title": "list of connection identifiers, in order, along which packets sent on this\nchannel will travel" + }, + "version": { + "type": "string", + "title": "opaque channel version, which is agreed upon during the handshake" + }, + "port_id": { + "type": "string", + "title": "port identifier" + }, + "channel_id": { + "type": "string", + "title": "channel identifier" + } + }, + "description": "IdentifiedChannel defines a channel with additional port and channel\nidentifier fields." + }, + "ibc.channel.Order": { + "type": "string", + "enum": [ + "ORDER_NONE_UNSPECIFIED", + "ORDER_UNORDERED", + "ORDER_ORDERED" + ], + "default": "ORDER_NONE_UNSPECIFIED", + "description": "- ORDER_NONE_UNSPECIFIED: zero-value for channel ordering\n - ORDER_UNORDERED: packets can be delivered in any order, which may differ from the order in\nwhich they were sent.\n - ORDER_ORDERED: packets are delivered exactly in the order which they were sent", + "title": "Order defines if a channel is ORDERED or UNORDERED" + }, + "ibc.channel.PacketAckCommitment": { + "type": "object", + "properties": { + "port_id": { + "type": "string", + "description": "channel port identifier." + }, + "channel_id": { + "type": "string", + "description": "channel unique identifier." + }, + "sequence": { + "type": "string", + "format": "uint64", + "description": "packet sequence." + }, + "hash": { + "type": "string", + "format": "byte", + "description": "packet commitment hash." } }, - "title": "QueryValidatorDelegationsResponse is response type for the Query/ValidatorDelegations RPC method" + "description": "PacketAckCommitment defines the genesis type necessary to retrieve and store\nacknowlegements." }, - "cosmos.staking.v1beta1.QueryValidatorResponse": { + "ibc.channel.QueryChannelClientStateResponse": { "type": "object", "properties": { - "validator": { - "description": "validator defines the the validator info.", + "identified_client_state": { + "title": "client state associated with the channel", "type": "object", "properties": { - "operator_address": { + "client_id": { "type": "string", - "format": "byte" - }, - "consensus_pubkey": { - "type": "string" - }, - "jailed": { - "type": "boolean", - "format": "boolean" - }, - "status": { - "type": "integer", - "format": "int32" - }, - "tokens": { - "type": "string" - }, - "delegator_shares": { - "type": "string" + "title": "client identifier" }, - "description": { + "client_state": { + "title": "client state", "type": "object", "properties": { - "moniker": { - "type": "string" - }, - "identity": { - "type": "string" - }, - "website": { - "type": "string" - }, - "security_contact": { - "type": "string" + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." }, - "details": { - "type": "string" + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." } }, - "description": "Description defines a validator description." + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + } + }, + "description": "IdentifiedClientState defines a client state with additional client identifier field." + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryChannelClientStateResponse is the Response type for the\nQuery/QueryChannelClientState RPC method" + }, + "ibc.channel.QueryChannelConsensusStateResponse": { + "type": "object", + "properties": { + "consensus_state": { + "title": "consensus state associated with the channel", + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." }, - "unbonding_height": { + "value": { "type": "string", - "format": "int64" + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "client_id": { + "type": "string", + "title": "client ID associated with the consensus state" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryChannelClientStateResponse is the Response type for the\nQuery/QueryChannelClientState RPC method" + }, + "ibc.channel.QueryChannelResponse": { + "type": "object", + "properties": { + "channel": { + "title": "channel associated with the request identifiers", + "type": "object", + "properties": { + "state": { + "title": "current state of the channel end", + "type": "string", + "enum": [ + "STATE_UNINITIALIZED_UNSPECIFIED", + "STATE_INIT", + "STATE_TRYOPEN", + "STATE_OPEN", + "STATE_CLOSED" + ], + "default": "STATE_UNINITIALIZED_UNSPECIFIED", + "description": "State defines if a channel is in one of the following states:\nCLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.\n\n - STATE_UNINITIALIZED_UNSPECIFIED: Default State\n - STATE_INIT: A channel has just started the opening handshake.\n - STATE_TRYOPEN: A channel has acknowledged the handshake step on the counterparty chain.\n - STATE_OPEN: A channel has completed the handshake. Open channels are\nready to send and receive packets.\n - STATE_CLOSED: A channel has been closed and can no longer be used to send or receive\npackets." }, - "unbonding_time": { + "ordering": { + "title": "whether the channel is ordered or unordered", "type": "string", - "format": "date-time" + "enum": [ + "ORDER_NONE_UNSPECIFIED", + "ORDER_UNORDERED", + "ORDER_ORDERED" + ], + "default": "ORDER_NONE_UNSPECIFIED", + "description": "- ORDER_NONE_UNSPECIFIED: zero-value for channel ordering\n - ORDER_UNORDERED: packets can be delivered in any order, which may differ from the order in\nwhich they were sent.\n - ORDER_ORDERED: packets are delivered exactly in the order which they were sent" }, - "commission": { + "counterparty": { + "title": "counterparty channel end", "type": "object", "properties": { - "commission_rates": { - "type": "object", - "properties": { - "rate": { - "type": "string" - }, - "max_rate": { - "type": "string" - }, - "max_change_rate": { - "type": "string" - } - }, - "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + "port_id": { + "type": "string", + "description": "port on the counterparty chain which owns the other end of the channel." }, - "update_time": { + "channel_id": { "type": "string", - "format": "date-time" + "title": "channel end on the counterparty chain" } + } + }, + "connection_hops": { + "type": "array", + "items": { + "type": "string" }, - "description": "Commission defines commission parameters for a given validator." + "title": "list of connection identifiers, in order, along which packets sent on this\nchannel will travel" }, - "min_self_delegation": { - "type": "string" + "version": { + "type": "string", + "title": "opaque channel version, which is agreed upon during the handshake" } - } + }, + "description": "Channel defines pipeline for exactly-once packet delivery between specific\nmodules on separate blockchains, which has at least one end capable of\nsending packets and one end capable of receiving packets." + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" } }, - "title": "QueryValidatorResponse is response type for the Query/Validator RPC method" + "description": "QueryChannelResponse is the response type for the Query/Channel RPC method.\nBesides the Channel end, it includes a proof and the height from which the\nproof was retrieved." }, - "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse": { + "ibc.channel.QueryChannelsResponse": { "type": "object", "properties": { - "unbonding_responses": { + "channels": { "type": "array", "items": { "type": "object", "properties": { - "delegator_address": { + "state": { + "title": "current state of the channel end", "type": "string", - "format": "byte" + "enum": [ + "STATE_UNINITIALIZED_UNSPECIFIED", + "STATE_INIT", + "STATE_TRYOPEN", + "STATE_OPEN", + "STATE_CLOSED" + ], + "default": "STATE_UNINITIALIZED_UNSPECIFIED", + "description": "State defines if a channel is in one of the following states:\nCLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.\n\n - STATE_UNINITIALIZED_UNSPECIFIED: Default State\n - STATE_INIT: A channel has just started the opening handshake.\n - STATE_TRYOPEN: A channel has acknowledged the handshake step on the counterparty chain.\n - STATE_OPEN: A channel has completed the handshake. Open channels are\nready to send and receive packets.\n - STATE_CLOSED: A channel has been closed and can no longer be used to send or receive\npackets." }, - "validator_address": { + "ordering": { + "title": "whether the channel is ordered or unordered", "type": "string", - "format": "byte" + "enum": [ + "ORDER_NONE_UNSPECIFIED", + "ORDER_UNORDERED", + "ORDER_ORDERED" + ], + "default": "ORDER_NONE_UNSPECIFIED", + "description": "- ORDER_NONE_UNSPECIFIED: zero-value for channel ordering\n - ORDER_UNORDERED: packets can be delivered in any order, which may differ from the order in\nwhich they were sent.\n - ORDER_ORDERED: packets are delivered exactly in the order which they were sent" }, - "entries": { - "type": "array", - "items": { - "type": "object", - "properties": { - "creation_height": { - "type": "string", - "format": "int64" - }, - "completion_time": { - "type": "string", - "format": "date-time" - }, - "initial_balance": { - "type": "string" - }, - "balance": { - "type": "string" - } + "counterparty": { + "title": "counterparty channel end", + "type": "object", + "properties": { + "port_id": { + "type": "string", + "description": "port on the counterparty chain which owns the other end of the channel." }, - "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." + "channel_id": { + "type": "string", + "title": "channel end on the counterparty chain" + } } + }, + "connection_hops": { + "type": "array", + "items": { + "type": "string" + }, + "title": "list of connection identifiers, in order, along which packets sent on this\nchannel will travel" + }, + "version": { + "type": "string", + "title": "opaque channel version, which is agreed upon during the handshake" + }, + "port_id": { + "type": "string", + "title": "port identifier" + }, + "channel_id": { + "type": "string", + "title": "channel identifier" } }, - "description": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list." - } + "description": "IdentifiedChannel defines a channel with additional port and channel\nidentifier fields." + }, + "description": "list of stored channels of the chain." }, "pagination": { - "description": "pagination defines the pagination in the response.", + "title": "pagination response", "type": "object", "properties": { "next_key": { @@ -8621,104 +12298,89 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - } + }, + "description": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest.\n\n message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }" + }, + "height": { + "type": "string", + "format": "int64", + "title": "query block height" } }, - "description": "QueryValidatorUnbondingDelegationsResponse is response type for the Query/ValidatorUnbondingDelegations RPC method." + "description": "QueryChannelsResponse is the response type for the Query/Channels RPC method." }, - "cosmos.staking.v1beta1.QueryValidatorsResponse": { + "ibc.channel.QueryConnectionChannelsResponse": { "type": "object", "properties": { - "validators": { + "channels": { "type": "array", "items": { "type": "object", "properties": { - "operator_address": { - "type": "string", - "format": "byte" - }, - "consensus_pubkey": { - "type": "string" - }, - "jailed": { - "type": "boolean", - "format": "boolean" - }, - "status": { - "type": "integer", - "format": "int32" - }, - "tokens": { - "type": "string" - }, - "delegator_shares": { - "type": "string" - }, - "description": { - "type": "object", - "properties": { - "moniker": { - "type": "string" - }, - "identity": { - "type": "string" - }, - "website": { - "type": "string" - }, - "security_contact": { - "type": "string" - }, - "details": { - "type": "string" - } - }, - "description": "Description defines a validator description." - }, - "unbonding_height": { + "state": { + "title": "current state of the channel end", "type": "string", - "format": "int64" + "enum": [ + "STATE_UNINITIALIZED_UNSPECIFIED", + "STATE_INIT", + "STATE_TRYOPEN", + "STATE_OPEN", + "STATE_CLOSED" + ], + "default": "STATE_UNINITIALIZED_UNSPECIFIED", + "description": "State defines if a channel is in one of the following states:\nCLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.\n\n - STATE_UNINITIALIZED_UNSPECIFIED: Default State\n - STATE_INIT: A channel has just started the opening handshake.\n - STATE_TRYOPEN: A channel has acknowledged the handshake step on the counterparty chain.\n - STATE_OPEN: A channel has completed the handshake. Open channels are\nready to send and receive packets.\n - STATE_CLOSED: A channel has been closed and can no longer be used to send or receive\npackets." }, - "unbonding_time": { + "ordering": { + "title": "whether the channel is ordered or unordered", "type": "string", - "format": "date-time" + "enum": [ + "ORDER_NONE_UNSPECIFIED", + "ORDER_UNORDERED", + "ORDER_ORDERED" + ], + "default": "ORDER_NONE_UNSPECIFIED", + "description": "- ORDER_NONE_UNSPECIFIED: zero-value for channel ordering\n - ORDER_UNORDERED: packets can be delivered in any order, which may differ from the order in\nwhich they were sent.\n - ORDER_ORDERED: packets are delivered exactly in the order which they were sent" }, - "commission": { + "counterparty": { + "title": "counterparty channel end", "type": "object", "properties": { - "commission_rates": { - "type": "object", - "properties": { - "rate": { - "type": "string" - }, - "max_rate": { - "type": "string" - }, - "max_change_rate": { - "type": "string" - } - }, - "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." + "port_id": { + "type": "string", + "description": "port on the counterparty chain which owns the other end of the channel." }, - "update_time": { + "channel_id": { "type": "string", - "format": "date-time" + "title": "channel end on the counterparty chain" } + } + }, + "connection_hops": { + "type": "array", + "items": { + "type": "string" }, - "description": "Commission defines commission parameters for a given validator." + "title": "list of connection identifiers, in order, along which packets sent on this\nchannel will travel" }, - "min_self_delegation": { - "type": "string" + "version": { + "type": "string", + "title": "opaque channel version, which is agreed upon during the handshake" + }, + "port_id": { + "type": "string", + "title": "port identifier" + }, + "channel_id": { + "type": "string", + "title": "channel identifier" } }, - "description": "Validator defines a validator, together with the total amount of the Validator's\nbond shares and their exchange rate to coins.\nSlashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." + "description": "IdentifiedChannel defines a channel with additional port and channel\nidentifier fields." }, - "description": "validators contains all the queried validators." + "description": "list of channels associated with a connection." }, "pagination": { - "description": "pagination defines the pagination in the response.", + "title": "pagination response", "type": "object", "properties": { "next_key": { @@ -8731,532 +12393,910 @@ "format": "uint64", "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" } - } + }, + "description": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest.\n\n message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }" + }, + "height": { + "type": "string", + "format": "int64", + "title": "query block height" } }, - "title": "QueryValidatorsResponse is response type for the Query/Validators RPC method" + "title": "QueryConnectionChannelsResponse is the Response type for the\nQuery/QueryConnectionChannels RPC method" }, - "cosmos.staking.v1beta1.Redelegation": { + "ibc.channel.QueryNextSequenceReceiveResponse": { "type": "object", "properties": { - "delegator_address": { + "next_sequence_receive": { "type": "string", - "format": "byte" + "format": "uint64", + "title": "next sequence receive number" }, - "validator_src_address": { + "proof": { "type": "string", - "format": "byte" + "format": "byte", + "title": "merkle proof of existence" }, - "validator_dst_address": { + "proof_path": { "type": "string", - "format": "byte" + "title": "merkle proof path" }, - "entries": { + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QuerySequenceResponse is the request type for the\nQuery/QueryNextSequenceReceiveResponse RPC method" + }, + "ibc.channel.QueryPacketAcknowledgementResponse": { + "type": "object", + "properties": { + "acknowledgement": { + "type": "string", + "format": "byte", + "title": "packet associated with the request fields" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryPacketAcknowledgementResponse defines the client query response for a\npacket which also includes a proof, its path and the height form which the\nproof was retrieved" + }, + "ibc.channel.QueryPacketCommitmentResponse": { + "type": "object", + "properties": { + "commitment": { + "type": "string", + "format": "byte", + "title": "packet associated with the request fields" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryPacketCommitmentResponse defines the client query response for a packet\nwhich also includes a proof, its path and the height form which the proof was\nretrieved" + }, + "ibc.channel.QueryPacketCommitmentsResponse": { + "type": "object", + "properties": { + "commitments": { "type": "array", "items": { "type": "object", "properties": { - "creation_height": { + "port_id": { "type": "string", - "format": "int64" + "description": "channel port identifier." }, - "completion_time": { + "channel_id": { "type": "string", - "format": "date-time" + "description": "channel unique identifier." }, - "initial_balance": { - "type": "string" + "sequence": { + "type": "string", + "format": "uint64", + "description": "packet sequence." }, - "shares_dst": { - "type": "string" + "hash": { + "type": "string", + "format": "byte", + "description": "packet commitment hash." } }, - "description": "RedelegationEntry defines a redelegation object with relevant metadata." + "description": "PacketAckCommitment defines the genesis type necessary to retrieve and store\nacknowlegements." } + }, + "pagination": { + "title": "pagination response", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest.\n\n message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }" + }, + "height": { + "type": "string", + "format": "int64", + "title": "query block height" } }, - "description": "Redelegation contains the list of a particular delegator's redelegating bonds\nfrom a particular source validator to a particular destination validator." + "title": "QueryPacketCommitmentsResponse is the request type for the\nQuery/QueryPacketCommitments RPC method" }, - "cosmos.staking.v1beta1.RedelegationEntry": { + "ibc.channel.QueryUnrelayedPacketsResponse": { "type": "object", "properties": { - "creation_height": { - "type": "string", - "format": "int64" + "sequences": { + "type": "array", + "items": { + "type": "string", + "format": "uint64" + }, + "title": "list of unrelayed packet sequences" }, - "completion_time": { + "height": { "type": "string", - "format": "date-time" - }, - "initial_balance": { - "type": "string" - }, - "shares_dst": { - "type": "string" + "format": "int64", + "title": "query block height" } }, - "description": "RedelegationEntry defines a redelegation object with relevant metadata." + "title": "QueryUnrelayedPacketsResponse is the request type for the\nQuery/UnrelayedPacketCommitments RPC method" }, - "cosmos.staking.v1beta1.RedelegationEntryResponse": { + "ibc.channel.State": { + "type": "string", + "enum": [ + "STATE_UNINITIALIZED_UNSPECIFIED", + "STATE_INIT", + "STATE_TRYOPEN", + "STATE_OPEN", + "STATE_CLOSED" + ], + "default": "STATE_UNINITIALIZED_UNSPECIFIED", + "description": "State defines if a channel is in one of the following states:\nCLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.\n\n - STATE_UNINITIALIZED_UNSPECIFIED: Default State\n - STATE_INIT: A channel has just started the opening handshake.\n - STATE_TRYOPEN: A channel has acknowledged the handshake step on the counterparty chain.\n - STATE_OPEN: A channel has completed the handshake. Open channels are\nready to send and receive packets.\n - STATE_CLOSED: A channel has been closed and can no longer be used to send or receive\npackets." + }, + "ibc.client.IdentifiedClientState": { "type": "object", "properties": { - "redelegation_entry": { + "client_id": { + "type": "string", + "title": "client identifier" + }, + "client_state": { + "title": "client state", "type": "object", "properties": { - "creation_height": { + "type_url": { "type": "string", - "format": "int64" + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." }, - "completion_time": { + "value": { "type": "string", - "format": "date-time" - }, - "initial_balance": { - "type": "string" - }, - "shares_dst": { - "type": "string" + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." } }, - "description": "RedelegationEntry defines a redelegation object with relevant metadata." - }, - "balance": { - "type": "string" + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" } }, - "description": "RedelegationEntryResponse is equivalent to a RedelegationEntry except that it\ncontains a balance in addition to shares which is more suitable for client\nresponses." + "description": "IdentifiedClientState defines a client state with additional client identifier field." }, - "cosmos.staking.v1beta1.RedelegationResponse": { + "ibc.client.QueryClientStateResponse": { "type": "object", "properties": { - "redelegation": { + "client_state": { + "title": "client state associated with the request identifier", "type": "object", "properties": { - "delegator_address": { - "type": "string", - "format": "byte" - }, - "validator_src_address": { + "type_url": { "type": "string", - "format": "byte" + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." }, - "validator_dst_address": { + "value": { "type": "string", - "format": "byte" - }, - "entries": { - "type": "array", - "items": { + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." + } + }, + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "description": "QueryClientStateResponse is the response type for the Query/ClientState RPC\nmethod. Besides the client state, it includes a proof and the height from\nwhich the proof was retrieved." + }, + "ibc.client.QueryClientStatesResponse": { + "type": "object", + "properties": { + "client_states": { + "type": "array", + "items": { + "type": "object", + "properties": { + "client_id": { + "type": "string", + "title": "client identifier" + }, + "client_state": { + "title": "client state", "type": "object", "properties": { - "creation_height": { + "type_url": { "type": "string", - "format": "int64" + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." }, - "completion_time": { + "value": { "type": "string", - "format": "date-time" - }, - "initial_balance": { - "type": "string" - }, - "shares_dst": { - "type": "string" + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." } }, - "description": "RedelegationEntry defines a redelegation object with relevant metadata." + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" } + }, + "description": "IdentifiedClientState defines a client state with additional client identifier field." + }, + "description": "list of stored ClientStates of the chain." + }, + "pagination": { + "title": "pagination response", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest.\n\n message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }" + } + }, + "description": "QueryClientStatesResponse is the response type for the Query/ClientStates RPC\nmethod." + }, + "ibc.client.QueryConsensusStateResponse": { + "type": "object", + "properties": { + "consensus_state": { + "title": "consensus state associated with the client identifier at the given height", + "type": "object", + "properties": { + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." + }, + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." } }, - "description": "Redelegation contains the list of a particular delegator's redelegating bonds\nfrom a particular source validator to a particular destination validator." + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" }, - "entries": { + "proof": { + "type": "string", + "format": "byte", + "title": "merkle proof of existence" + }, + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryConsensusStateResponse is the response type for the Query/ConsensusState RPC method" + }, + "ibc.client.QueryConsensusStatesResponse": { + "type": "object", + "properties": { + "consensus_states": { "type": "array", "items": { "type": "object", "properties": { - "redelegation_entry": { - "type": "object", - "properties": { - "creation_height": { - "type": "string", - "format": "int64" - }, - "completion_time": { - "type": "string", - "format": "date-time" - }, - "initial_balance": { - "type": "string" - }, - "shares_dst": { - "type": "string" - } - }, - "description": "RedelegationEntry defines a redelegation object with relevant metadata." + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." }, - "balance": { - "type": "string" + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." } }, - "description": "RedelegationEntryResponse is equivalent to a RedelegationEntry except that it\ncontains a balance in addition to shares which is more suitable for client\nresponses." - } + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" + }, + "title": "consensus states associated with the identifier" + }, + "pagination": { + "title": "pagination response", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest.\n\n message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }" } }, - "description": "RedelegationResponse is equivalent to a Redelegation except that its entries\ncontain a balance in addition to shares which is more suitable for client\nresponses." + "title": "QueryConsensusStatesResponse is the response type for the Query/ConsensusStates RPC method" }, - "cosmos.staking.v1beta1.UnbondingDelegation": { + "ibc.commitment.MerklePrefix": { "type": "object", "properties": { - "delegator_address": { + "key_prefix": { "type": "string", "format": "byte" - }, - "validator_address": { + } + }, + "title": "MerklePrefix is merkle path prefixed to the key.\nThe constructed key from the Path and the key will be append(Path.KeyPath, append(Path.KeyPrefix, key...))" + }, + "ibc.connection.ConnectionEnd": { + "type": "object", + "properties": { + "client_id": { "type": "string", - "format": "byte" + "description": "client associated with this connection." }, - "entries": { + "versions": { "type": "array", "items": { - "type": "object", - "properties": { - "creation_height": { - "type": "string", - "format": "int64" - }, - "completion_time": { - "type": "string", - "format": "date-time" - }, - "initial_balance": { - "type": "string" - }, - "balance": { - "type": "string" - } + "type": "string" + }, + "title": "IBC version which can be utilised to determine encodings or protocols for\nchannels or packets utilising this connection" + }, + "state": { + "description": "current state of the connection end.", + "type": "string", + "enum": [ + "STATE_UNINITIALIZED_UNSPECIFIED", + "STATE_INIT", + "STATE_TRYOPEN", + "STATE_OPEN" + ], + "default": "STATE_UNINITIALIZED_UNSPECIFIED" + }, + "counterparty": { + "description": "counterparty chain associated with this connection.", + "type": "object", + "properties": { + "client_id": { + "type": "string", + "description": "identifies the client on the counterparty chain associated with a given\nconnection." }, - "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." + "connection_id": { + "type": "string", + "description": "identifies the connection end on the counterparty chain associated with a\ngiven connection." + }, + "prefix": { + "title": "commitment merkle prefix of the counterparty chain", + "type": "object", + "properties": { + "key_prefix": { + "type": "string", + "format": "byte" + } + } + } } } }, - "description": "UnbondingDelegation stores all of a single delegator's unbonding bonds\nfor a single validator in an time-ordered list." + "description": "ConnectionEnd defines a stateful object on a chain connected to another\nseparate one. NOTE: there must only be 2 defined ConnectionEnds to establish\na connection between two chains." }, - "cosmos.staking.v1beta1.UnbondingDelegationEntry": { + "ibc.connection.Counterparty": { "type": "object", "properties": { - "creation_height": { + "client_id": { "type": "string", - "format": "int64" + "description": "identifies the client on the counterparty chain associated with a given\nconnection." }, - "completion_time": { + "connection_id": { "type": "string", - "format": "date-time" + "description": "identifies the connection end on the counterparty chain associated with a\ngiven connection." }, - "initial_balance": { - "type": "string" - }, - "balance": { - "type": "string" + "prefix": { + "title": "commitment merkle prefix of the counterparty chain", + "type": "object", + "properties": { + "key_prefix": { + "type": "string", + "format": "byte" + } + } } }, - "description": "UnbondingDelegationEntry defines an unbonding object with relevant metadata." + "description": "Counterparty defines the counterparty chain associated with a connection end." }, - "cosmos.staking.v1beta1.Validator": { + "ibc.connection.IdentifiedConnection": { "type": "object", "properties": { - "operator_address": { + "id": { "type": "string", - "format": "byte" - }, - "consensus_pubkey": { - "type": "string" - }, - "jailed": { - "type": "boolean", - "format": "boolean" + "description": "connection identifier." }, - "status": { - "type": "integer", - "format": "int32" + "client_id": { + "type": "string", + "description": "client associated with this connection." }, - "tokens": { - "type": "string" + "versions": { + "type": "array", + "items": { + "type": "string" + }, + "title": "IBC version which can be utilised to determine encodings or protocols for\nchannels or packets utilising this connection" }, - "delegator_shares": { - "type": "string" + "state": { + "description": "current state of the connection end.", + "type": "string", + "enum": [ + "STATE_UNINITIALIZED_UNSPECIFIED", + "STATE_INIT", + "STATE_TRYOPEN", + "STATE_OPEN" + ], + "default": "STATE_UNINITIALIZED_UNSPECIFIED" }, - "description": { + "counterparty": { + "description": "counterparty chain associated with this connection.", "type": "object", "properties": { - "moniker": { - "type": "string" - }, - "identity": { - "type": "string" - }, - "website": { - "type": "string" + "client_id": { + "type": "string", + "description": "identifies the client on the counterparty chain associated with a given\nconnection." }, - "security_contact": { - "type": "string" + "connection_id": { + "type": "string", + "description": "identifies the connection end on the counterparty chain associated with a\ngiven connection." }, - "details": { - "type": "string" + "prefix": { + "title": "commitment merkle prefix of the counterparty chain", + "type": "object", + "properties": { + "key_prefix": { + "type": "string", + "format": "byte" + } + } } + } + } + }, + "description": "IdentifiedConnection defines a connection with additional connection\nidentifier field." + }, + "ibc.connection.QueryClientConnectionsResponse": { + "type": "object", + "properties": { + "connection_paths": { + "type": "array", + "items": { + "type": "string" }, - "description": "Description defines a validator description." + "description": "slice of all the connection paths associated with a client." }, - "unbonding_height": { + "proof": { "type": "string", - "format": "int64" + "format": "byte", + "title": "merkle proof of existence" }, - "unbonding_time": { + "proof_path": { "type": "string", - "format": "date-time" + "title": "merkle proof path" }, - "commission": { + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was generated" + } + }, + "title": "QueryClientConnectionsResponse is the response type for the\nQuery/ClientConnections RPC method" + }, + "ibc.connection.QueryConnectionClientStateResponse": { + "type": "object", + "properties": { + "identified_client_state": { + "title": "client state associated with the channel", "type": "object", "properties": { - "commission_rates": { + "client_id": { + "type": "string", + "title": "client identifier" + }, + "client_state": { + "title": "client state", "type": "object", "properties": { - "rate": { - "type": "string" - }, - "max_rate": { - "type": "string" + "type_url": { + "type": "string", + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." }, - "max_change_rate": { - "type": "string" + "value": { + "type": "string", + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." } }, - "description": "CommissionRates defines the initial commission rates to be used for creating\na validator." - }, - "update_time": { - "type": "string", - "format": "date-time" + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" } }, - "description": "Commission defines commission parameters for a given validator." + "description": "IdentifiedClientState defines a client state with additional client identifier field." }, - "min_self_delegation": { - "type": "string" - } - }, - "description": "Validator defines a validator, together with the total amount of the Validator's\nbond shares and their exchange rate to coins.\nSlashing results in a decrease in the exchange rate, allowing correct\ncalculation of future undelegations without iterating over delegators.\nWhen coins are delegated to this validator, the validator is credited with a\ndelegation whose number of bond shares is based on the amount of coins\ndelegated divided by the current exchange rate. Voting power can be\ncalculated as total bonded shares multiplied by exchange rate." - }, - "tendermint.types.BlockID": { - "type": "object", - "properties": { - "hash": { + "proof": { "type": "string", - "format": "byte" + "format": "byte", + "title": "merkle proof of existence" }, - "part_set_header": { - "type": "object", - "properties": { - "total": { - "type": "integer", - "format": "int64" - }, - "hash": { - "type": "string", - "format": "byte" - } - }, - "title": "PartsetHeader" + "proof_path": { + "type": "string", + "title": "merkle proof path" + }, + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" } }, - "title": "BlockID" + "title": "QueryConnectionClientStateResponse is the response type for the\nQuery/ConnectionClientState RPC method" }, - "tendermint.types.Header": { + "ibc.connection.QueryConnectionConsensusStateResponse": { "type": "object", "properties": { - "version": { - "title": "basic block info", + "consensus_state": { + "title": "consensus state associated with the channel", "type": "object", "properties": { - "block": { + "type_url": { "type": "string", - "format": "uint64" + "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n URL, or have them precompiled into a binary to avoid any\n lookup. Therefore, binary compatibility needs to be preserved\n on changes to types. (Use versioned type names to manage\n breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics." }, - "app": { + "value": { "type": "string", - "format": "uint64" + "format": "byte", + "description": "Must be a valid serialized protocol buffer of the above specified type." } }, - "description": "Consensus captures the consensus rules for processing a block in the blockchain,\nincluding all blockchain data structures and the rules of the application's\nstate transition machine." + "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n Foo foo = ...;\n Any any;\n any.PackFrom(foo);\n ...\n if (any.UnpackTo(&foo)) {\n ...\n }\n\nExample 2: Pack and unpack a message in Java.\n\n Foo foo = ...;\n Any any = Any.pack(foo);\n ...\n if (any.is(Foo.class)) {\n foo = any.unpack(Foo.class);\n }\n\n Example 3: Pack and unpack a message in Python.\n\n foo = Foo(...)\n any = Any()\n any.Pack(foo)\n ...\n if any.Is(Foo.DESCRIPTOR):\n any.Unpack(foo)\n ...\n\n Example 4: Pack and unpack a message in Go\n\n foo := &pb.Foo{...}\n any, err := ptypes.MarshalAny(foo)\n ...\n foo := &pb.Foo{}\n if err := ptypes.UnmarshalAny(any, foo); err != nil {\n ...\n }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n package google.profile;\n message Person {\n string first_name = 1;\n string last_name = 2;\n }\n\n {\n \"@type\": \"type.googleapis.com/google.profile.Person\",\n \"firstName\": ,\n \"lastName\": \n }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n {\n \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n \"value\": \"1.212s\"\n }" }, - "chain_id": { - "type": "string" + "client_id": { + "type": "string", + "title": "client ID associated with the consensus state" }, - "height": { + "proof": { "type": "string", - "format": "int64" + "format": "byte", + "title": "merkle proof of existence" }, - "time": { + "proof_path": { "type": "string", - "format": "date-time" + "title": "merkle proof path" }, - "last_block_id": { - "title": "prev block info", + "proof_height": { + "type": "string", + "format": "uint64", + "title": "height at which the proof was retrieved" + } + }, + "title": "QueryConnectionConsensusStateResponse is the response type for the\nQuery/ConnectionConsensusState RPC method" + }, + "ibc.connection.QueryConnectionResponse": { + "type": "object", + "properties": { + "connection": { + "title": "connection associated with the request identifier", "type": "object", "properties": { - "hash": { + "client_id": { "type": "string", - "format": "byte" + "description": "client associated with this connection." }, - "part_set_header": { + "versions": { + "type": "array", + "items": { + "type": "string" + }, + "title": "IBC version which can be utilised to determine encodings or protocols for\nchannels or packets utilising this connection" + }, + "state": { + "description": "current state of the connection end.", + "type": "string", + "enum": [ + "STATE_UNINITIALIZED_UNSPECIFIED", + "STATE_INIT", + "STATE_TRYOPEN", + "STATE_OPEN" + ], + "default": "STATE_UNINITIALIZED_UNSPECIFIED" + }, + "counterparty": { + "description": "counterparty chain associated with this connection.", "type": "object", "properties": { - "total": { - "type": "integer", - "format": "int64" + "client_id": { + "type": "string", + "description": "identifies the client on the counterparty chain associated with a given\nconnection." }, - "hash": { + "connection_id": { "type": "string", - "format": "byte" + "description": "identifies the connection end on the counterparty chain associated with a\ngiven connection." + }, + "prefix": { + "title": "commitment merkle prefix of the counterparty chain", + "type": "object", + "properties": { + "key_prefix": { + "type": "string", + "format": "byte" + } + } } - }, - "title": "PartsetHeader" + } } - } - }, - "last_commit_hash": { - "type": "string", - "format": "byte", - "title": "hashes of block data" - }, - "data_hash": { - "type": "string", - "format": "byte" + }, + "description": "ConnectionEnd defines a stateful object on a chain connected to another\nseparate one. NOTE: there must only be 2 defined ConnectionEnds to establish\na connection between two chains." }, - "validators_hash": { + "proof": { "type": "string", "format": "byte", - "title": "hashes from the app output from the prev block" - }, - "next_validators_hash": { - "type": "string", - "format": "byte" - }, - "consensus_hash": { - "type": "string", - "format": "byte" - }, - "app_hash": { - "type": "string", - "format": "byte" - }, - "last_results_hash": { - "type": "string", - "format": "byte" + "title": "merkle proof of existence" }, - "evidence_hash": { + "proof_path": { "type": "string", - "format": "byte", - "title": "consensus info" + "title": "merkle proof path" }, - "proposer_address": { + "proof_height": { "type": "string", - "format": "byte" + "format": "uint64", + "title": "height at which the proof was retrieved" } }, - "description": "Header defines the structure of a Tendermint block header." + "description": "QueryConnectionResponse is the response type for the Query/Connection RPC\nmethod. Besides the connection end, it includes a proof and the height from\nwhich the proof was retrieved." }, - "tendermint.types.PartSetHeader": { + "ibc.connection.QueryConnectionsResponse": { "type": "object", "properties": { - "total": { - "type": "integer", - "format": "int64" + "connections": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "string", + "description": "connection identifier." + }, + "client_id": { + "type": "string", + "description": "client associated with this connection." + }, + "versions": { + "type": "array", + "items": { + "type": "string" + }, + "title": "IBC version which can be utilised to determine encodings or protocols for\nchannels or packets utilising this connection" + }, + "state": { + "description": "current state of the connection end.", + "type": "string", + "enum": [ + "STATE_UNINITIALIZED_UNSPECIFIED", + "STATE_INIT", + "STATE_TRYOPEN", + "STATE_OPEN" + ], + "default": "STATE_UNINITIALIZED_UNSPECIFIED" + }, + "counterparty": { + "description": "counterparty chain associated with this connection.", + "type": "object", + "properties": { + "client_id": { + "type": "string", + "description": "identifies the client on the counterparty chain associated with a given\nconnection." + }, + "connection_id": { + "type": "string", + "description": "identifies the connection end on the counterparty chain associated with a\ngiven connection." + }, + "prefix": { + "title": "commitment merkle prefix of the counterparty chain", + "type": "object", + "properties": { + "key_prefix": { + "type": "string", + "format": "byte" + } + } + } + } + } + }, + "description": "IdentifiedConnection defines a connection with additional connection\nidentifier field." + }, + "description": "list of stored connections of the chain." }, - "hash": { + "pagination": { + "title": "pagination response", + "type": "object", + "properties": { + "next_key": { + "type": "string", + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" + }, + "total": { + "type": "string", + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + }, + "description": "PageResponse is to be embedded in gRPC response messages where the corresponding\nrequest message has used PageRequest.\n\n message SomeResponse {\n repeated Bar results = 1;\n PageResponse page = 2;\n }" + }, + "height": { "type": "string", - "format": "byte" + "format": "int64", + "title": "query block height" } }, - "title": "PartsetHeader" + "description": "QueryConnectionsResponse is the response type for the Query/Connections RPC\nmethod." }, - "tendermint.version.Consensus": { + "ibc.connection.State": { + "type": "string", + "enum": [ + "STATE_UNINITIALIZED_UNSPECIFIED", + "STATE_INIT", + "STATE_TRYOPEN", + "STATE_OPEN" + ], + "default": "STATE_UNINITIALIZED_UNSPECIFIED", + "description": "State defines if a connection is in one of the following states:\nINIT, TRYOPEN, OPEN or UNINITIALIZED.\n\n - STATE_UNINITIALIZED_UNSPECIFIED: Default State\n - STATE_INIT: A connection end has just started the opening handshake.\n - STATE_TRYOPEN: A connection end has acknowledged the handshake step on the counterparty\nchain.\n - STATE_OPEN: A connection end has completed the handshake." + }, + "ibc.transfer.DenomTrace": { "type": "object", "properties": { - "block": { + "path": { "type": "string", - "format": "uint64" + "description": "path defines the chain of port/channel identifiers used for tracing the source of the fungible\ntoken." }, - "app": { + "base_denom": { "type": "string", - "format": "uint64" + "description": "base denomination of the relayed fungible token." } }, - "description": "Consensus captures the consensus rules for processing a block in the blockchain,\nincluding all blockchain data structures and the rules of the application's\nstate transition machine." + "description": "DenomTrace contains the base denomination for ICS20 fungible tokens and the source tracing\ninformation path." }, - "cosmos.upgrade.v1beta1.Plan": { + "ibc.transfer.Params": { "type": "object", "properties": { - "name": { - "type": "string", - "description": "Sets the name for the upgrade. This name will be used by the upgraded version of the software to apply any\nspecial \"on-upgrade\" commands during the first BeginBlock method after the upgrade is applied. It is also used\nto detect whether a software version can handle a given upgrade. If no upgrade handler with this name has been\nset in the software, it will be assumed that the software is out-of-date when the upgrade Time or Height\nis reached and the software will exit." - }, - "time": { - "type": "string", - "format": "date-time", - "description": "The time after which the upgrade must be performed.\nLeave set to its zero value to use a pre-defined Height instead." - }, - "height": { - "type": "string", - "format": "int64", - "description": "The height at which the upgrade must be performed.\nOnly used if Time is not set." + "send_enabled": { + "type": "boolean", + "format": "boolean", + "description": "send_enabled enables or disables all cross-chain token transfers from this chain." }, - "info": { - "type": "string", - "title": "Any application specific upgrade info to be included on-chain\nsuch as a git commit that validators could automatically upgrade to" + "receive_enabled": { + "type": "boolean", + "format": "boolean", + "description": "receive_enabled enables or disables all cross-chain token transfers to this chain." } }, - "description": "Plan specifies information about a planned upgrade and when it should occur." + "description": "Params defines the set of IBC transfer parameters.\nNOTE: To prevent a single token from being transferred, set the TransfersEnabled parameter to\ntrue and then set the bank module's SendEnabled parameter for the denomination to false." }, - "cosmos.upgrade.v1beta1.QueryAppliedPlanResponse": { + "ibc.transfer.QueryDenomTraceResponse": { "type": "object", "properties": { - "height": { - "type": "string", - "format": "int64", - "description": "height is the block height at which the plan was applied." + "denom_trace": { + "description": "denom_trace returns the requested denomination trace information.", + "type": "object", + "properties": { + "path": { + "type": "string", + "description": "path defines the chain of port/channel identifiers used for tracing the source of the fungible\ntoken." + }, + "base_denom": { + "type": "string", + "description": "base denomination of the relayed fungible token." + } + } } }, - "description": "QueryAppliedPlanResponse is the response type for the Query/AppliedPlan RPC method." + "description": "QueryDenomTraceResponse is the response type for the Query/DenomTrace RPC method." }, - "cosmos.upgrade.v1beta1.QueryCurrentPlanResponse": { + "ibc.transfer.QueryDenomTracesResponse": { "type": "object", "properties": { - "plan": { - "description": "plan is the current upgrade plan.", + "denom_traces": { + "type": "array", + "items": { + "type": "object", + "properties": { + "path": { + "type": "string", + "description": "path defines the chain of port/channel identifiers used for tracing the source of the fungible\ntoken." + }, + "base_denom": { + "type": "string", + "description": "base denomination of the relayed fungible token." + } + }, + "description": "DenomTrace contains the base denomination for ICS20 fungible tokens and the source tracing\ninformation path." + }, + "description": "denom_traces returns all denominations trace information." + }, + "pagination": { + "description": "pagination defines the pagination in the response.", "type": "object", "properties": { - "name": { - "type": "string", - "description": "Sets the name for the upgrade. This name will be used by the upgraded version of the software to apply any\nspecial \"on-upgrade\" commands during the first BeginBlock method after the upgrade is applied. It is also used\nto detect whether a software version can handle a given upgrade. If no upgrade handler with this name has been\nset in the software, it will be assumed that the software is out-of-date when the upgrade Time or Height\nis reached and the software will exit." - }, - "time": { + "next_key": { "type": "string", - "format": "date-time", - "description": "The time after which the upgrade must be performed.\nLeave set to its zero value to use a pre-defined Height instead." + "format": "byte", + "title": "next_key is the key to be passed to PageRequest.key to\nquery the next page most efficiently" }, - "height": { + "total": { "type": "string", - "format": "int64", - "description": "The height at which the upgrade must be performed.\nOnly used if Time is not set." + "format": "uint64", + "title": "total is total number of results available if PageRequest.count_total\nwas set, its value is undefined otherwise" + } + } + } + }, + "description": "QueryConnectionsResponse is the response type for the Query/DenomTraces RPC method." + }, + "ibc.transfer.QueryParamsResponse": { + "type": "object", + "properties": { + "params": { + "description": "params defines the parameters of the module.", + "type": "object", + "properties": { + "send_enabled": { + "type": "boolean", + "format": "boolean", + "description": "send_enabled enables or disables all cross-chain token transfers from this chain." }, - "info": { - "type": "string", - "title": "Any application specific upgrade info to be included on-chain\nsuch as a git commit that validators could automatically upgrade to" + "receive_enabled": { + "type": "boolean", + "format": "boolean", + "description": "receive_enabled enables or disables all cross-chain token transfers to this chain." } } } }, - "description": "QueryCurrentPlanResponse is the response type for the Query/CurrentPlan RPC method." + "description": "QueryParamsResponse is the response type for the Query/Params RPC method." } } } \ No newline at end of file From 3f1b6d1ba17445627c83a276c43c38a4d60f9e62 Mon Sep 17 00:00:00 2001 From: anilCSE Date: Fri, 28 Aug 2020 00:41:43 +0530 Subject: [PATCH 23/27] Update swagger generation doc --- scripts/protoc-swagger-gen.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/scripts/protoc-swagger-gen.sh b/scripts/protoc-swagger-gen.sh index 48a54a2c8806..e62e891818a2 100755 --- a/scripts/protoc-swagger-gen.sh +++ b/scripts/protoc-swagger-gen.sh @@ -18,6 +18,7 @@ done # combine swagger files # uses nodejs package `swagger-combine`. +# all the individual swagger files need to be configured in `config.json` for merging swagger-combine ./client/grpc-gateway/config.json -o ./client/grpc-gateway/swagger.json --continueOnConflictingPaths true --includeDefinitions true # clean swagger files From 9461dd375e04079286025686a1533130a28ab10e Mon Sep 17 00:00:00 2001 From: anilCSE Date: Fri, 28 Aug 2020 00:44:01 +0530 Subject: [PATCH 24/27] cleanup --- scripts/protocgen.sh | 17 ----------------- 1 file changed, 17 deletions(-) diff --git a/scripts/protocgen.sh b/scripts/protocgen.sh index 747d3a45e294..dc65afbbecc3 100755 --- a/scripts/protocgen.sh +++ b/scripts/protocgen.sh @@ -17,25 +17,8 @@ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. \ -I "third_party/proto" \ --grpc-gateway_out=logtostderr=true:. \ $(find "${dir}" -maxdepth 1 -name '*.proto') - - # generate swagger only for query files - query_file=$(find "${dir}" -maxdepth 1 -name 'query.proto') - if [[ ! -z "$query_file" ]]; then - protoc \ - -I "proto" \ - -I "third_party/proto" \ - "$query_file" \ - --swagger_out=logtostderr=true,stderrthreshold=1000,fqn_for_swagger_name=true,simple_operation_ids=true:. - fi done -# combine swagger files -# uses nodejs package `swagger-combine`. -swagger-combine ./client/grpc-gateway/config.json -o ./client/grpc-gateway/swagger.json --continueOnConflictingPaths true --includeDefinitions true - -# clean swagger files -find ./ -name 'query.swagger.json' -exec rm {} \; - # generate codec/testdata proto code protoc -I "proto" -I "third_party/proto" -I "testutil/testdata" --gocosmos_out=plugins=interfacetype+grpc,\ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. ./testutil/testdata/proto.proto From 05512e2bd8649746516c00b68332ba8faa135eb1 Mon Sep 17 00:00:00 2001 From: anilCSE Date: Fri, 28 Aug 2020 00:47:31 +0530 Subject: [PATCH 25/27] gofmt --- scripts/protocgen.sh | 1 + x/gov/simulation/genesis_test.go | 6 +++--- x/staking/keeper/grpc_query_test.go | 2 +- 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/scripts/protocgen.sh b/scripts/protocgen.sh index dc65afbbecc3..74447d849774 100755 --- a/scripts/protocgen.sh +++ b/scripts/protocgen.sh @@ -17,6 +17,7 @@ Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. \ -I "third_party/proto" \ --grpc-gateway_out=logtostderr=true:. \ $(find "${dir}" -maxdepth 1 -name '*.proto') + done # generate codec/testdata proto code diff --git a/x/gov/simulation/genesis_test.go b/x/gov/simulation/genesis_test.go index 46c86febb19f..db8b98bff103 100644 --- a/x/gov/simulation/genesis_test.go +++ b/x/gov/simulation/genesis_test.go @@ -72,9 +72,9 @@ func TestRandomizedGenState1(t *testing.T) { module.SimulationState{}, "invalid memory address or nil pointer dereference"}, { // panic => reason: incomplete initialization of the simState module.SimulationState{ - AppParams: make(simtypes.AppParams), - Cdc: cdc, - Rand: r, + AppParams: make(simtypes.AppParams), + Cdc: cdc, + Rand: r, }, "assignment to entry in nil map"}, } diff --git a/x/staking/keeper/grpc_query_test.go b/x/staking/keeper/grpc_query_test.go index f2c4c9ab31ad..7fd2ee7dd0ba 100644 --- a/x/staking/keeper/grpc_query_test.go +++ b/x/staking/keeper/grpc_query_test.go @@ -68,7 +68,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryValidators() { suite.Equal(tc.numVals, len(valsResp.Validators)) suite.Equal(uint64(len(vals)), valsResp.Pagination.Total) - if (tc.hasNext) { + if tc.hasNext { suite.NotNil(valsResp.Pagination.NextKey) } else { suite.Nil(valsResp.Pagination.NextKey) From 41d8baf77e547cdeca448901d0109729a14138e5 Mon Sep 17 00:00:00 2001 From: anilCSE Date: Fri, 28 Aug 2020 00:47:56 +0530 Subject: [PATCH 26/27] refactor --- scripts/protoc-swagger-gen.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/protoc-swagger-gen.sh b/scripts/protoc-swagger-gen.sh index e62e891818a2..979960c91643 100755 --- a/scripts/protoc-swagger-gen.sh +++ b/scripts/protoc-swagger-gen.sh @@ -22,4 +22,4 @@ done swagger-combine ./client/grpc-gateway/config.json -o ./client/grpc-gateway/swagger.json --continueOnConflictingPaths true --includeDefinitions true # clean swagger files -find ./ -name 'query.swagger.json' -exec rm {} \; \ No newline at end of file +find ./ -name 'query.swagger.json' -exec rm {} \; From c26067d9aa48bd3fa8e4026c5f5f39983431e013 Mon Sep 17 00:00:00 2001 From: Federico Kunze Date: Fri, 28 Aug 2020 20:40:56 +0200 Subject: [PATCH 27/27] update Makefile --- Makefile | 2 +- client/grpc-gateway/statik/statik.go | 13 +++++++++++++ 2 files changed, 14 insertions(+), 1 deletion(-) create mode 100644 client/grpc-gateway/statik/statik.go diff --git a/Makefile b/Makefile index 416132198314..c3f3a06d6d28 100644 --- a/Makefile +++ b/Makefile @@ -139,7 +139,7 @@ go.sum: go.mod ############################################################################### update-swagger-docs: statik - $(BINDIR)/statik -src=client/lcd/swagger-ui -dest=client/lcd -f -m + $(BINDIR)/statik -src=client/grpc-gateway -dest=client/grpc-gateway -f -m @if [ -n "$(git status --porcelain)" ]; then \ echo "\033[91mSwagger docs are out of sync!!!\033[0m";\ exit 1;\ diff --git a/client/grpc-gateway/statik/statik.go b/client/grpc-gateway/statik/statik.go new file mode 100644 index 000000000000..475addf4ab05 --- /dev/null +++ b/client/grpc-gateway/statik/statik.go @@ -0,0 +1,13 @@ +// Code generated by statik. DO NOT EDIT. + +// Package statik contains static assets. +package statik + +import ( + "github.com/rakyll/statik/fs" +) + +func init() { + data := "PK\x03\x04\x14\x00\x08\x00\x08\x00\x00\x00!(\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0b\x00 \x00config.jsonUT\x05\x00\x01\x80Cm8\xbc\xd5\xcf\xab\x9b@\x10\x07\xf0\xbb\x7f\xc5\xb0\xe7T\x93\x1es\xeb3%l\xdb\xbb25\xdd\xbb{\"\xae\xe6\xf8\xc4q\xdb\xea\x19\xcd\xed\xb1umyN\xccNu\xd0`\x11$kU\x04\xd8\x05\x94d\x8e\xa3\xff\xfb\x0d\xbcU\xa1\xdeQ|\x91%u\xf2\x83M\xb1P@\"\x01$\x12O>\x00\xbe>\x038\x11wd\xb9\xa4\xd9\xc99\x9c\xfc0\xf9\xc3\xc9\xa9\xfa-a\x0b~r\x0e\xea9\xc0\x89LdJ\xd5\xf37\\\xac\xb9\x80\x8fo\xff_x \x7f\xfap\xf5\x06\xfeD$\xbd#[\xfd\x16\xc0\xc9-\xcdD\xc2\x99J\xfb\xfd\xe4\x0f\x93?\x9c<\x03\xf8M\xe7\xb8!r%\xca,\xcfb\x9d\xd5\x19\xc9\xe5\xea\xec\xf6\xfb\x19\x95\xe4\xfb3\x12\xc7\x9f>\xfc|\x96Q\xc1\xf3,\xa6\xc0\xc8\x9a\x82\\\x11 9K~\xcdi\xba\x85dN\x99L\x16\x89U\x87*\xc7\xe9B\xd0,!i\xf2O:\x8f\xd8&\xe3\x92\xc7<\x85Y\xbeX\xd0\x0c\xd6T\x08\xb2\xa4\x13\xb8^%\x02\x8cT\xb0\xce\x85\x84\x983I\x12\x06DBJ\x89\x90\x11\xe3\x8cBtr\x16\x9d@\xbc\"\x19\x89%\xcd\xd4{\x14R\"$\x08\xba\\\xd3\xb2\x01>}\xf8\xf9;\x01jD\x99\xec2\xba\xc9\xa8\xa0LFL=^\xe4i\xba\x85_s\x92*\x99\xe7\xa6F\xf6U-\xfbs\" a\x11\xfb\xac\xb28[r\xbeL\xe9DK?\xcb\x17\x93\xb7\xb9\x19\x0d\x9f_\x18 \xf4\xebb\xc5\xf3t\x0e3\nJl\x88 \xe3,\x89I\n\x0b\x9e\xad#\xf6\x9cN\x96\x93SU\x19\xdd'\xa2\x93It\x02\x89\x00\xc6\xa5\xea=t#\xe9\xfc\xc5$b\x11\xbbd\xb0Q\xf5Kbz\n\x92\x92\xb5\x80\\\xe4DI\xbc\xc9h\xcc\xd7\x9b$U\x85H\xae\xe5\x9d%\x8cd[ i\xaaE\x17\xa6e\xe4\x8an#F\xbflh,!\x91 9\xe4B\x8bf\xfa'\x93\xf4\x8b\xd6\xd6k\xb6\x9d\xc0\x9f\xf9\x1d\xbd\xa5\xd9\xa9\x92U\xe9N\xc0\xdd*\x89W\xfa\x15\xb9\xa2\x11\xd3c\x8f\xc2\xe7\x95\x94\x9b\xcf\xa7\xe6\x7f\xf1\xf9\x14x\x06\x8c\x83yz\n\xaa\x89b\xc2\x80\xeb\x9e\xa3%\x16TB\xbe\x01\xa2e\x8b\x98\xa0\xd9-\xcd\x8c\x88k\xb2\x11F\xdb\xbaD\xc9]w0#+Qy\x08 \x02\x16Q/\xbcf\xf0\xe7\xeb\xeb+\xf8\xd3\xc5\xb5\xb2o\xb6{\x98~\xb1Mh:\x07\x02\xff\xa87\xf1\xf5vC\x7f\xf9\xc7/\x11\x03\xb8%i\xae5g5\xad\xda\x93H]\xf7M\xc6\xe7yL\x810\xa0Y\xc63S\xdef\x93&1\xb1\xe2gT5\x0d\xbf\xa3sU\xc3\x98\xc4\xaa\xc7r~\x93o\x94\xa5\xcbS\xe9\x99^\xadjP\xd2\xe9\xdcW\xe4V\xab\x7f\xed\xb5\xfb\xdc4\xcb(\xb9Q\xbd\xdb\xe60y\xa1\x9a\xec\x1d\x97\xf4\x1c\xa4\x1a\xe1\x8b\x9c\xc5\xa6k(\x19l\xef\x8f\xf3,\xa3L\xa6[ \xb7$I\xc9,-\xfa)_,\x928!\xa9\xb5\x1c\xb3|\x01\x19U\xf6\x80\x9e\x02as\xd5\xb1m&\xb9R\xa1\xea\xbde\x87\x9a\xd1e\xc2\x98\x12\xe7.\x91\xab\x88\xa9'\x13\xd3\xced\x93\x88I\xcc\xd7z\xbc}\xd4]I\x00\x97+\xd35Y\xbd\x9f\xc3s\x95\xf1\x8a\x02]o\xe4\xd6\xf6\xbd\x17\xb0N\x96+ 3\x1a1]\xba*\x05\x92\xf5&\xa5\xca\x12\xe9\xf6\x07\xb1\xa1q\xb2Hb\x10tM\x98Lb19i5\xba\xbf\xb5\xdb\xe2\x13\xdd\xf9\x0ea\xd2M\xafU)g[I\x83M\xff_\xd5(\x99Q j\x18$s\xcf\x9aC\xdd\x98[\xfbIf\xfc\x96\xba\x8a\xdb\xce\xd2U\xe9\x96_\x9b\xbf\xd5\x7fi\xa8\xaa.\xf3\xff\x97\xd3lk}\x94\x0f\xd6\x9bP\xfdDI\xe7\xbc\x0b\xd3O\x16\xb6]\xf5\x1bg\xceER^\xdb\x9a\xca\x15\x9f\xd7\xe4\xf6%\xa9Hq2\xa7\x0b\x92\xa7M\x0f\xa21\x932\xc8\xadU\xa6sc3\n\x91\xee\xcf\xdf\xd1\xe5vy;\xb5\x0e\xd5l\x8ef\xd79\x89\xf9\xbc\xab\x93\x16\xf9%LR\xe5D\xb7:8e\xefL\x98\xfc\xf7\x1f\xc2J\xb5\xd3\xc5P\xc1c*b\xbd\xe1\xa1,I\x96\x15\x1e}-I\"\xe9z\xc0K\x1b\xf0\xf6\x86\x1b\xd0\xa6\n\xf0\xf8\xc2\x0d\x04z}\xe8\xf5\xa1\xd7\x87^\x1fz}\xf7\xe8\xf5u\xfa}\x01\x9e\xdf(\xd3\x1e\xe8\xfd\xdd\xb3\xff\xd7\xee\x01v;\xc35\xd9>\xbff\xdb\xcfn\xce\x10j8\x92l\x96\xc8L\xf5\xfb\x1e9\x9d\xbd!)\xb7\xbd\x04H\xc4\x94q\xd0\x06\xca\x142\xeb\x9d\xd3\x8a)L\xf5\xa4+\xd7I\xd3d\xa6\xcb\xb6\xb6I\x80\xc87\x1b\x9ei3\xbc!\xf1\xcdY\xce\xd4\x7f\xca\xf8\x1a\xf3\"\\\x8f7\x93\x05_@.\xcd@uCF(\x8b@\xe6\xf3\xc4\x8c\x1fXRF3\"\xb5\x04\xcaA\x15N6\x95\xa7\xd6\xb4\x92\xe8\xe2\x0bQ\x1d\x12\xbe?\x87+U\xa0\x1a4\xb6lRT?a\xf0\xe6\xdf\xfeM\xa7W\xca\xfd\x89sXp\x0e\xaf`2\x99\xfc\xd1\xfc\xa62%lk\xff\"l;Q\xd9\xfd\x94\xf1\xf5\xf3\x05\xe7/\xec\xef\x93\xc9\xc4|I\x16\xf0\\%\xfa\xa4\x8b\xba\xe6\xcf\xffE\xa5z\x01_\xcdc/\xe5o\xbe\x94?\x0cH\xf9\x17rKB\xc4\x84WzZS\x19\xf4\x8a\x97\x88\xe7?q>\x89S\"\x84/\x9d\xc9V\xa50Rx\xa9\xfe\xe8\x89\x0dN\xee\x7f\x1f\x90\xfbj+W\x9c\x15\x92\x9b\xec\x7f\xe2\xfc\xf9d\xa2L\xa4U\xa9\x91\xfa\xf9\x8b\xaa\x8eu\x05\x9a\xf2\xab\xc7\x97F\xfc\xb7\x17\x1f\xdf|\xb8\xbc\xba~\xff\xe1\xc5\xb9\xabA\xa9|\xef}\x9b\x83'\xf8\x7f\x0c\x08\xfe'\xeed\xd6B\x9f\xbf\x82\x7f\xd9\xcc&?q\xfeu2\x99\xfcf\x9f\x10\xb6=U\xd3\x9fz\xbc1\x13\xc6_I&V$U\xd5\xf1\x8a/\xe4\xafg\xe6rJ\x16\xb5|>\xb1u\x99\x93.G7\xa7N\xf5?^\x01K\xd2\xb2\xd1\xbc\xecu\xeb(\xc7L\xd7\xc8\x8d\x0f\xe7(\xc0l\x0b\x9b\xfaH\xbdK\xd2T=\xb0\xcb75\x9fD\xec\xbb\x96)\xe3L\xf9\x8e\x13\xfd@\xcd\x80\xdf)\x07\xa50\x0f\xcat(]\xaa\x1f\x8c>#V\x0cO\x96n\x9dC\xd5p@\x8b\x19\x15\xc8BR3\xd9h\xbf\xf6\xbb\xb3\xef\"fm\x83+\xc2\xb8i\xd4\xb6at\xb2\xe0|2#\x99\x96\xee\xcb\xd9v\xf2\xcf\xe8\xc4\xd4\xc7x7\xc6\xf3\xd2\x99G'\xfa\xa9\xee\x04\x11\xfb\xcb\xc7\xf7\xef\"\xf6\xea\xd5\xabWF[\xea\xef\xd2S6\x13\x18W]\x0d\x8c}5\x8eP.\xa8[@/\xf3\x94d\x11k\xbe\xa2\x1e\xcfii%O\x81\xaegt>/\xed\xe5\xa95\xb7,b\x9eQ[h\x81?\xff\x1f%\xf2g\xeb\x83\x16V\xddW\xc1\xc4u\xe1s\xd7A\x95\xb2U\xaf-\x1d\xb9E\x92R;\\]\x97\xbe\xa2\x99\xe0\xac\xec3v\xc5\xb1H2!\xa7ZC\xaf\xe0\xfb?\xd6\x9e\xaavp\x0f\x7f\xa8\x8c\x7f\x802\xab\xe8DK\x1d\x9d\x9cCt\xd2\xd6o\xaa\x82M\x8c(\xd1\xc9i\x99\x81\x16\xe3\x1dY\xebL\xfe\x97)\xfd\x7f{\xcf\x95 \xf5\xc7\x9e8\x97\x0b\xeb\xa3T5mt\x96\x08\xb8\xa3i\xfa\xf2\x86\xf1;\xa6\xfb\xe8\x8a\x08\xb5L\xc9\x85\xe4k0]\xa1\xda\x90\xa7f\x16\xac\xb5\xae\x19(^1\xaa\xf9\xd8\x12\x88i\xbc\x88}\xd6\xdd\xc4\xb5\xde\x8a\xa7s\xd3t^Iz\x85d[\x1d\xec2\xc66z\xc4t6E\xfb\xc2s\xd5\xd7]U\x1an\xba[\x89\xfd\xf2\x8f_^\x9c\xef\xd3&\xd5\xec*\xcd\xa2\xebc\xf2\xf8~\xf2\xc3\xf7?\x88\xe8\xc4j\xbd\xcd\x97 @\xad\x9eu\xfdU~\xf7\xfc\x9e\x93\x0d\xc9\xc8\x9aJ\x9a\x89\x93s\xf8\x87\x97\xbc\x060\xa9.\xaa! \x13d\xaa\x83H\xf5\xd8\x95IU\x8d]\xd9\xdf$\x87_sj\x96:\x8d\xe0[\xa2_W\xeb\xe2\xfa\x93\x8c\xfe\x9a'\x19\x9d\x9f\x9c\x83\xccrZ{\xda\xeb\xa2\xd6\xdd\xd2V\xa5\xfc\xe2)E\x92e]\x1d\x06\xed+_\xfd\xe5\x99\x9f\x81\xd5h{0U\xabX\x84\x06P\xaftj\xad\xa2\x84\n\xbd\xf2.\xdb\xa87Z\x9a\xcb\x95y\xf9\xc9\x04L\x1b\x9a\xab<\xad k\x12W\xba\\\xa987o\xac\xf9-\xb0\xa4A|-`y\xe5\xf5\xe2\xe6G;c%z\xcdq\xc9\xa4\xb5z\xc5*\xb0b\xfa\x8c'\x101\x91,\x19\x91yF\x05\xb8\xb0\xa3r=\x96|\xc9\xb5%j]#\xb5\xd6\xad^3\xd7\xe3\x1c\xc4]\xfcm\xc7\xa6\xc1~\x12\xd6\xb6\nm\x03A7diu\x11\x1c%s/\xd4\"e\xc5\xcf\xd6\x97\xe9\x1a\x8e6\xdb\x80\x8e\x1d\xd2\xadO\x18\xfd\"\xa77t;\x04\x9e\x06\xac\x9dCW\xce\xe5.ZW\xb8k\x0d\xf5\xd5\".D\x08\x03\x08]\x91%\xfd@\x7f\xcd\xa9\x90\x13\xf3P\x9f\x93a}\xd9\x84\xfdK\xa8F\xf2\xde%U\xfd\xd3>K@\xbf\xf0\xf5N\xfe\x91\xb2\xf9\x85\xa9\x8dakW\xed\x14\x01\xbf\x7f\x80\x90D\xe6\x02\x9e\xdf\xad\xa8f\xd2\xda`\xaaYz\xb2\xb9J\xf4\xe2`\xf4O\xedQN\xc7\xf6\xcf!M\x87\xea\xb8u\xb6m\x1de5\x8d^\xf5\xee\"t\x1ew\xc5\xac5r\xdd\xcd\xe5\xaf\xed\x81\xf2%h\xba\xfd\x05\x04jM\xac\xbfE\xf4Y\x97,\xe8\xf4{\xef\xa0\xd3_$A\xa7\xffq;\xfd\x87\xf5\x01E\xbe\xd9\xa4\xdbP\x1f\xf0\x9aK\x92~\xd4\xafT\x1cA\x03\xa8\x9a\xbc*\xc4\xb3>7\xd0\xcb\xec\xc9\xf8\x81\x0duV\x9e>\xac\xd19\xec\x87\xed=4\x07\xa1\xb7\xf02Z\x7f\xefvH\x9e*\xc3\xac\xe0\xf1\xd8\xc1fW\xac\xe5\xd0+8e\xbbx*E\xee\xda\xa0x\x03t\x0c4\xe9\x1b\x89\x12\x9eDG\xa5\xd9\x1e\xe8\xa8<\x10S\x88\x8e\xca#qT\xc6\x06\x0d\x8d\x19z\xbf\xa8x+\x9e\x9f\xe2\x07\x0d\xfb|\x15\x97\xcf\x93qTzg\xe6\x06\"l\xa6\xbe\xce\xb9\x06\xa3\x83;\x8e\xa8F\xb3\xb5A\x05\xae\xef\x8d\x99\x83\x8b~\x8f\xf1\xc1\xb1\x13\x17\xce\xc0E\x12\x9c\x81\x1f\xf7\x0c<6>\x88\x81\xb2\xc2\xf7\x98'\xaa\xa8Y\xae\xaa]\xf8 1_\xafs\x96\xc8\xedt\xc3y\x1a\xea\x83\xbcqo]q\x9eV\x1c\x91\"?P\xf9\x0d#&\x95\x9c\x9e\x8c+R\xd3e\xe5\xd9\xc32RC\x8e\xc8\x01,\xd4\xa0;\x12^F\xeb\xef\x81\x88\xc9[\x1a\x8f\x03M`N\xe3dM\xd2`\xec\xe4-\x8d\xef\x1b;\xa9o\x8eSc\xceU\xb0:\x14\xbf\x13\xdd\xfb\xf2j\xbf\x84\xf9p\x95\x91;\xc6\x91\xab\x1a\x0f\xf4\xe6\xc6:A\xe8\xcd\x15I\xee\xd1P\xa27w\x04o\xee8>\xcd\x9c\xa6tI$\xcf\xc4\xd9\xd7\xe2\xfb\xb4 ig\xf4\x8eds\x11\xea\xeb\xbc59$\x9ci\x14\xf8\x83y\xbb%Vd\xf3\x05\x12\xc7YnL:1\x1b\x1b\xf4qVJ\x88>O\xa8\xbd\x9c'\xe3\x125\xb5^y\xfc\xb0\x06{\xd1`\xae\xd7\xdc\xf3\x90\xec\xb4\x0fF\x8ba\xd2\xf4S\xa5\x06\x15j\x13\x05\xa9\xd5\xa6\x0dR\xaeM;\xecx\xda\x84a&\xd5|:\x15g>!\xae\xa8M9\xaa\xd4\x9e\xa7\xbd\x12=1\x17\xd5|\xba\xb4\xb1\xa7\xf3\xee\x8c\xe3[g\xd0\x8d\x81,\x0f\x0f\xb2\\\xa7\xa2\x0b\xea3\xee\x94\x86l\xfa\xef\x84\xfb\xae\xd4g\x06\xd2\xee\x9e\xb63\xf6ES\xd9\xb3/Z'\x81B\x86\xc0C1\xfa\x0eS\x08\x18\xde\xf7i)\x87\x87q\xe0P\xc2\xf5\xe3q\x07gP\xaf6\x8e\x8c\xcf\xdc\x13\xf9\xda?\xda\xc5v\xef\x83-\"\xdb\x9d\x9e1\xab\xc9\x0e\xf7\x0c\x97\x95cWc\xb8\xac,\x92\xdc\xa3\xfd\xc4e\xe5\x11\x96\x95\xe3\x83\x04\xb5E\xe2`\xc0\xa0\x96\xbeb2\x8b\xa7\xbf\xab\x1b\x83\xf6X\x89\x9f}m\xac\xb7\x82\xd9\x10\xa5\xf9\x1f\xb90/}\xc1\xb0E9\xae\xc7\xebI\xee\xd1J\xa2\x97\xf9\x94\xbc\xcc\xfa\xdaih\xdd\xa4\xc7h#\xdf}\x1d\xce\xbd|Mt3C\xc6\x03\xba\x99\x0f\xc5\x80\xa2\x9b\x89n\xe6=\xbb\x99\xa7\xc3\ni\xc2\xec\xfd\ni\xa4\xaf(\xa4x\xfa@\x15R|\xff\xe6~w\xa1\xa9\xb1A0\x9e\xfd\xadx\xb5\xe2h\x979B\x15u\x0dp\xae\xfdL\x9f\x8c{\xdd\xaa\xe2J\x8a\xc3M\x10\xbd\xb64\xc0\x8e\x069m^\x0b\xb7\x0e:\xe1\xb7\xbar\xa6\x9c\xf3\xc6\x96f\xf85\xca\xd8\xcb\x81\xf3;\xcd\x0e.\\\xa5#\xa3\x137\xd6\xf7A'\xaeH\x128F\xd1\x89C'\xee\x11:q\xc5\xf7o\xee\xb3\xdc%r5\xcf\xc8]\x0b##\xccs\xf9\xbf6\x83\xd7V\xd1\xce}q\x19\x17-\xb0\x83\x03S\xcb\xfb\xc9x1=J\xaf\xa4\x0b0\x08\xf5^\x16\xe2s\xd4\x8b\x1f5t\x1a\xf9\xef\xe9o\xd4\xdax'\xa7\xa3\xde\x07\xd1\xf3\x18;a\xa3\xe7Q$A\xcf\x03=\x8fJB\xf4\xeb\x91\xe4\x89Q\xc8\xe0\xd0\x06\xbb1\xa2\xabG\x02\xb6\xd8\xa61>^\x9b\xe1\xc4#\x02G\xbaI\xe8\xef\x15I\xd0\xdf{\xdc\xfe\xdeXT\x0f9P\xdf\xc6E\xe6\xb9\x14\x92\xb0y\xc2\x96\xd3\x91'\x02\x14&\xff}\x99G}\xf7\x81\xe33\xeb`b\xa3U\x82|\xe5f\xeeO\xc6g\x0e\xdc|\xb0\xafO\xdb_\x0c\x84Yd\x18\xb6\xca\x10(\xb4M\x19 \xbaM\x89\x0e\xed\xef\xcf\xa1m\xed\xed5\x8d\xf4Y oC\xbcg\xe3\xe0y\xce^:x\x96\xbdp\xf6)b\xb5U<$\xda\xbdd\"\xb9\xa5\xe6rR\x12\xdf\x9c\x02IS~'@h\xf5\x80 \xfaX\xa9xE\xe3\x9b\xc3\xed\x05\xee\xa9\xd4N\x0ey\x8bn\x10\x89\x1d\xeb\xd0\xa2g^$A\xcf\x1c=\xf3JB\xf4\xcc\x8f\xe2\x99\x8b\x94\x88\x15\x1d\xef\x8d\x7f4\xef\x15.\xb8\xce\x07\xe8\xad\x99\n\x17\xa3\xb1j\x9b\xdf\x93q\xba\x9bz\xad<~X\x16\xb0\xec\x17\x1b\x9a%<\xf0\xc8\xab1f\xaay\xef\xbb\xff\xe9\xb6\x9a\x8b\x8c\xc4\xb2\x1f&\x0f\xb7\xcd\xad\xbfwE\xd7\xbb\x9c@\xddQ/T?\xf7\x9d?\xdf\xa9\xf3\x86\xc2$b\x7f\xa6\xc9re.q_o\xd2$\xd6\x97\xf4\xcb\x95\xbd\xce_H\x9eQ\xb8\xa1\xdbI\xc4\xaeW\x89\xbe4\x95Q:\xa7se\xb1b\x92\xc6:\x14\x04d\xa3Z2K\xf4\xf7\xb5\xbb\x8b^Hr\xa3\xdcM\xed\xa1[\xf7\xb2\xdc\xc6+\xac\x97M2Z\xf0n\x19\x90\x85\xd4\x97\xf9\x19)WD\x00\x8f\xe3<\xcb\xe8\x1e\xe73\xd9\xce^=\xcb\xc6\xfe\xd6\x15_id\xdb\xe6G\x94\x97\xe8w\x0d\xa4\x06\xb7\xa5\xb8u\xbf\xcao\xf1/\xe3\xf7\x9d\xda#\x07z\x18\xfd\"\xa77\xb4\xebF'\x181\x9eB8\xbd:]\x81\xb8\xbb\xc2\x9d#\xaf\xbeJ\x0e3\xa5\x0f!L\x17\xbb\"K\xfa\x81\xfe\x9aS!'\xe6y\xc4\xccD\xa9\xdeP9(\xe5QXs!\x81.\x16I\x9cP&\xd3m\xfb \xeb\x1aL}gl\xc1n:\xb0\x16eX\x0b\xe6X\n\xa5\x02\xfd\x85\xe5\xeb\x19\xcd\xd4\xe8\xc9\xa8\xc8S5voI\x92\x92YJ!YT\xf4\xa1o\xfd\x9f\xea\xd7\"vG\x04\x08*O!\x91\x02\xb43\xa7\xf2\xcc\x99\xe9fs\xe0rE\xb3\xbbDtxc;z]\x8dy\xa7w-g'\xd1\x9d\x16pnB\xc7U[\xdfL\x82\xab\xb6\x87\xe2\xb3\xe0\xaa-\xc4~<\xeb\xfa\x0bWm\xe3Wm\xa7\xc3\n\x11\x92d2a\xcb\xe9J\xbb}\x03\xea\xa8\xa5\xae(\x83\xebT$\x05\x97\x08l\xa2B'\x9e\x97\xd5\xa1\x1b\x9d\xaeG9\x0b\x92\x8a]\xb5\xd3\xf4\xe8C\xf4CM\x0c\xe8p\xda1\x19> \xdd\x94N\xaa\xf2\xc4\x06\x94c\xdd:b]\x91\x8c\xca\xcb\xa8\xe0y\x16SP\xa6\xc6\x98\x82\x9c%\xbf\xe64\xdd\x82R\x96L\x16\xc5y\x9f\xdb\x0du\x06@\xd0,!i\xf2O:\x8f\x98\x0e\xce\xc7<\x85Y\xbeX\xd0\x0c\xecJu\x02\x1a\xe04r\xc1:\x17\x12b\xce$I\x18\x10 )%BFL\xcd\x81\xd1\xc9Yt\x02\xf1\x8ad$\x964\x9bh\x1eAJ\x84\xb2D\xcb5-\xad\xce\xa7\x0f?\x7f'@-\x00Lv\x05\x1e\x1b1\xf5x\x91\xa7\xfa\x9ay\x92*\x99\xe7\xa6F\xce`)\xd9\x9f\x13\x01\xca!\xfa\xac\xb28[r\xbeL\xe9DK?\xcb\x17\x93\xb7\xb9\xe9\xfe\x9f_\x18 \xf4\xeb\xa5\xdf\xa3\xc4V.\x00gILRe\xe1\xd6\x11{N'\xcb\xc9\xa9\xaa\x8c\xf6J\xa3\x93It\xa2!].\x81\xc41\xddH:\x7f\xa1\x19\x12\x97\x0c6\x1a\xdb\x8e\xe9)HJ\xd6\xca\xbe\xe5DI\xbc\xc9h\xcc\xd7\x9b$U\x85(\x0b\xbd\xa20K\x18\xc9\xb6\xe6d\xf0\xedF7\x801\xd2\xdb\xc8\"*j\xb2\x93\\\x19I73*\xed*\xef\x8e/\xe05\xdbN\xe0\xcf\xfc\x8e\xde\xd2\xecT[\xe3O\x1f~v\xf8\xb0zE\xaeh\xc4\xf4@\xa3\xf0y%\xe5\xe6\xf3\xa9\xf9_|>U\xae\x08\xe3`\x9e\x9ej7E\xb9>\xce\x05O\xb7z\x86\xc87@\xb4l\x11\x134\xbb\xa5\x99\x11qM6\xc2h[\x97(\xb9\xeb\x0e\xc6\x9dO\x0cPM\x04,\xb8f=\x9c+\xe5\xfc+\\.\xca\"\x95\x027\x19Wcu^H\xa5\xdd2!\xf25\x9dO\xd4\x0b\xaf\x19\xfc\xf9\xfa\xfa\n\xfetq\x0d\x96\xd5\xff\xe9\xc3\xcf\xa6_l5\xf9\x84\xc0?\xeaM|\xbd\xdd\xd0_\xfe\xf1K\xc4\xc0!z\xcci\xda\xd8w]\xf7M\xc6\xe7yL\x810\x83Y\x99\xf26\x9bTM\x97F\xfc\x8c\x1a\xd2\x86\x83\xedc\xd5c9\xbf\xc97\x85\xf72#\xcaO4\xa2\xa9\x02?}\xf8Y\xe7\xbe\"\xb7Z\xfdk\xaf\xdd\xe7\xa6\xe1\x89\x13F}\xbf\xe5\xc9\x1c\x08\xdb\xaawM\xd6\xba[ft\xc13z\xeaR\xaa\x0c\x88LfI\x9a\xc8\xad\x8e$8\xbfI\x0f\x8d\xecV\x0dPPb\xc4+\xc2\x96T?\xd5=j\x02\xcf? \n\xb74\x13 W\xfe\x95n4\xd5\xe9M\xab\x11F\x96Z\xf0YFM\xd4\xc1\xe60y\xa1\x19?\\\xd2s\x90j\x84/r\x16\x9b\xae\xa1d\xb0\xbd_\x87\x18\xd4\xb2\xc2\x87[M;q\xed\x16+\x17\xc05\x0cdT\xd9\x03z\xaa\x19F\xc63T\x99hW[\xe3\x97E\x87\xd2k\x1a\xa6\xc4\xb9K\xe4*b\xea\xc9\xc4\xb43\xd9$b\x12\xf3\xb5\x1eo\x1fuW\x12\x06\xa65\xfew\xad\x9f\xc3s\x0b\x8c\x1a\xdf\xd1\xf4\xbd\x17\xb0\xd6\x0b\xcb\x19\x8d\x98q\xf4\x13\xe9\xf1\x96\x8c;\xa3\xfc\x95d\x91\xc4 \xe8\x9a0\x99\xc4m4\x1d\xf3\xf96HS\xf8$\xf0W5^f\xd4\xc5\xb3<\xbb\x0eu\xb3n-)\x99\xf1[\xeaT`\xbb\xcdXfV\xc7\xb4X\x93\xed\xf3k\xb6\xfd\xec\xe6\x0c\xcd$#\xd9,\x91\x99\xea\xf7=r:{CRn{ \x90\x88)\xe3\xa0\x0d\x94)d\xd6;\xa7\x15S\x98\xeaIW\xae\x93\xa6\xc9L\x97mm\x93\xd0\x17[\xf3L\x9b\xe1\x0d\x89o\xcer\xa6\xfeS\xc6\xd7\x98\x17\xe1z\xbc\x99,\xf8\x02ri\x06\xaa\x1b2\x02\x0c\xf8\x95XtcI\x99r\xc2\xb4\x04r\xc5\xe7\xc5\xf6l\x95\xa7\xd6\xb4\x92\xe8\xe2\x0b\xd1L\xb1\xef\xcf\xe1J\x15\xa8\x06\x8d-\x9b\x14\xd5O\x18\xbc\xf9\xb7\x7f\xd3\xe9\x95r\x7f\xe2\x1c\x16\x9c\xc3+\x98L&\x7f4\xbf\xa9L \xdb\xda\xbf\x08\xdbNTv?e|\xfd|\xc1\xf9\x0b\xfb\xfbd21_\x92\x05\xe9\xa2\xae\xf9\xf3\x7fQ\xa9^\xc0W\xf3\xd8K\xf9\x9b/\xe5\x0f\x03R\xfe\x85\xdc\x92\x101\xe1\x95\x9e\xd6T\x06\xbd\xe2%\xe2\xf9O\x9cO\xe2\x94\x08\xe1Kg\xb2U)\x8c\x14^\xaa?zb\x83\x93\xfb\xdf\x07\xe4\xbe\xda\xca\x15g\x85\xe4&\xfb\x9f8\x7f>\x99(\x13iUj\xa4~\xfe\xa2\xaac]\x81\xa6\xfc\xea\xf1\xa5\x11\xff\xed\xc5\xc77\x1f.\xaf\xae\xdf\x7fxq\xeejP*\xdf{\xdf\xe6\xe0 \xfe\x1f\x03\x82\xff\x89;\x99\xb5\xd0\xe7\xaf\xe0_6\xb3\xc9O\x9c\x7f\x9dL&\xbf\xd9'\x84mO\xd5\xf4\xa7\x1eo\xcc\x84\xf1W\x92\x89\x15IUu\xbc\xe2\x0b\xf9\xeb\x99\xb9\x9c\x92E-\x9fOl]\xe6\xa4\xcb\xd1\xcd\xa9S\xfd\x8fW\xc0\x92\xb4l4/{\xdd:\xd7:\xb8\x1b\xdf\x14\xe3\xc39\njY\xbf\xa9\x8fT\x0d\x06\xcc\xb6\x05\x1e\x90\x0b\x1a\xb1\xefZ\xa6\x8c3\xe5;N\xf4\x035\x03~\xa7\x1c\x94\xc2<(\xd3\xa1t\xa9~0\xfa\x8cX1<\xd5\n\xd6:T\x0d\x07\xb4\x98Qm\x10^:\xbf\xf6\xbb\xb3\xef\"fm\x83+\xc2\xb8i\xd4\xb6at\xb2\xe0|2#\x99\x96\xee\xcb\xd9v\xf2\xcf\xe8\xc4\xd4\xc7x7\xc6\xf3\xd2\x99G'\xfa\xa9\xee\x04\x11\xfb\xcb\xc7\xf7\xef\"\xf6\xea\xd5\xabWF[\xea\xef\xd2S6\x13\x18W]\x0d\x8c}5\x8eP.\x8a\xa3\xc2\x97yJ\xb2\x885_\x91\xfa`\x93\xd2J\x9e\x02]\xcf\xe8|^\xda\xcbSknY\xc4<\xa3f\xb8\xc0\x9f\xff\x8f\x12\xf9\xb3\xf5A\x0b\xab\xee\xab`\xe2\xba\xf0\xb9\xeb\xa0J\xd9\xaa\xd7\x96\x8e\xdc\"I\xa9\x1d\xae\xaeK_\xd1LpV\xf6\x19\xbb\xe2X$\x99\x90S\xad\xa1W\xf0\xfd\x1fkOU;\xb8\x87?T\xc6?@\x99Ut\xa2\xa5\x8eN\xce!:i\xeb7U\xc1&F\x94\xe8\xe4\xb4\xcc@\x8b\xf1\x8e\xacu&\xff\xcb\x94\xfe\xbf\xbd\xe7J\x90\xfacO\x9c\xcb\x85\xf5Q\xaa\x9a6:K\x04\xdc\xd14}y\xc3\xf8\x9dag\xaf\x88P\xcb\x14C\xac6]\xa1\xda\x90\xa7f\x16\xac\xb5\xae\x19(^1\xaa\xf9\xd8\x12\x88i\xbc\x88}\xd6\xdd\xc4\xb5\xde\x8a\xa7\xf3\n\x85[w2\xb5B\xb2\xad\x0ev\x19c\x1b=b:\x9b\xa2}\xe1\xb9\xea\xeb\xae*\x0d7\xdd\xad\xc4~\xf9\xc7//\xce\xf7i\x93jv\x95f\xd1\xf51y|?\xf9\xe1\xfb\x1fDtb\xb5\xbe3+\xc6\xa1\x0b\x16\xb2\xacB-\xadL\xeef\xae\xc8\x80\xf1\xd3\x05\xba\xb5\xc8\x80\x01\xf8}1`\x14H\x086\xe9\x81A\x84{\x0d!\x1c\x93J\xb2\x0b\x8f\x04I$\xd0\xd2\xa5\x9a\x0d\xd2\xec\xf4\xfb\xd0\xefC\xbf\x0f\xfd\xbeA\xbf\x0fI$\xad\xbf#\x89\x04I$H\"A\x12 \x92H\x90D\"\x91D\x82$\x12$\x91\x94\xc9;\"\xc3\x95@\xe0@@\xb8\x92\xb6\xb2\xc1P\xff`\x87\xf2p\x0c\xeb\xfe\x0f\xef,\xbe\x1f4\xbe\xba\xe4\xb7Eh\xd5\xdc\xab\x7f\xf6\xd5\xfc?U\x92\x06\x87U\xed\xe5\xe5\xfe\xa1\\\xcd;\xf9\x97\xfc\xb6\xe5^\xfezT\xf5O\xfc\xd6\xe4\xf6d\xc2\xaa\xb7\\\x1f\x03j\xf4\x1a\x18[\xad\xbcS\xdb [\xe85\xa3\xe6\x9ee\xc9\xc1\xa4?r\xa8\xd5 5t\xc9B\xe8\xf2\xac^\xe9\x9f)[\xcab\x14\x9a\xd2\xc0\x94\xb6\x1f\x92\xde\x8awn\xb8H\xe4\xb8V\xa9\xbe\x14\xd0,\xf6\x85#\xb7\xcb:aS[RH\xab\xe0\xf5u\x0f\xf7\xfa\xbaqw\xd7\xb1\xe0K\xeb.\x99<\xf2\xa5u\xa1\x83\xfc\xaf K\xd6\xf9\xda\x0d\x0d0w\xca\xa9~\xc2\x05I\xd5\xa0\xa1L- \x82\x86\x7f\x07\\\xb2&_\xa6\xc5X=\x96\xb5\xfa+\xf9\xa2+b\n\xd0\xf5x\xadT\xa9\\@e\x06\xca\xe1\x0f\xaa\xbd\x8a*N\xe0\x92%2!\xa9Y`\x9c\xc3\x0f\xb0\xe6L\xae:C\xa4;\xdb8I\xd2t;\xce\xc2\xf9\xaf\x04\xd87\x9d\xfc\xc8\xd6\xed\xd7\x9cgy\x9fe\x08n\xc0@,\xb0\xab\xc7nh\x16\xabu\xc1\xd2\xe0b\x9a\x00($\xb9\xa1\xde\x957\xb7\\R\xdb\xa5-\x97\xd0`\xce1g\"\x99S5\x9c4\x9c8\xb2C\xcbUF\x85\xeaX\x0fA\x0d\xaa\x1fgn\xe9\xfbw*t\xa5\x85aB\xdf\x14\xa3>\x01($\x8c7\xf5\xc1h$\xb4L\x0cGF$\xa1\x13\x95\x84~e!:\x89\xe8$\xa2\x93\x88N\":\x89\xe8$\xa2\x93\x88N> t\x12z\x91\x04\x83@\x85\x01 \x83\xfe\xdd e\x9a\xcc\xfa\x8f>\xa7\xf2\xea\xc3\xfb\xab\xf7\x1f_\xff<\xfdx\xfd\xfa\xfa\xd3\xc7\xe9\xa7w\x1f\xaf.\xde\\\xfety\xf1\xb6\xd7\x19l\xbc\xf8\xf6\xe2\xea\xfd\xc7\xcb\xeb\xe9\xd5\xc5\x87\xcb\xf7#\xdf\xfd\xdb\xfb\xeb\xcbw\x7f\xda\xe9\xd5\xab\xd7\x1f?\x8e\x15\xf5\xc3\xc5_.\xde\\\x8f}\xeb\xa7\xd7\x97?_\xbc\xed\xf6U\x7f\xe9\xf5G\x1d'qG\x85\xd7=Z\x07D~\xd4\x1d\x06\xa8>B\x97Hkz\xad7\xae\x9fQ\xed\xf9y\x9cp=\x0c^B\x8f\x1c\xe7}\x0f+Tm7\x1d\xea\xcc7\xc2\xb0\x94e.&\xadET\xbbH\xb3\x94\xeasooBAm5\xb9\xc3<\xcf\xdc\x11\xcb\x8e\xf7n\xc9\xfb\xad\xe5V\xbaW\xb3\xd8\xca\xe3\xb0R\xab;\x06Z\x0b5\x1d\xb3Y\x9a\xf9\xbd\xa7\x98Jk\x19\x1b\xabl\xb1\xb9\x86\xaf\xbd,\xd7\xa1\x9b\xa5\xb9'\xe3\xcb\x9bQ\xca \xa3\xff\xad\xe9\xb1\xed\xc5\x9a\x11\xd1,\xd4\xfc>\xbe\xc8\x05IR\xda\xc5W\xef3\x9b\x8b\x84\x91tj6\x14\x18T%\xcc\x84\x1e\x12\x8b\xdd\x0e& \xe0\xc1\x96\x9f\x81-E3\xa1\x9c\x9e\xfb+\x90\xf1\xfb,k\xaa\x9c\xbf\xe9-\x95\x87-\xf5\x10P\xc2\xb5\xead\x1f\xcc~\x8b\xb2\x83\x0bI\xd8\x9cds\xb3K\xc5\xee\xcaX\xf2[\x9a1\xc2bZ\x1a\xdf\xf1}[\xe4\xb3u\"\xa72Y\x1f\x81\x816'\x92\xbe\xd4Y\x8f\x96\xcbmz\xa2l\xfe\xf0\x84\xd3;f\x026*\x06\xc5\xb7l\xc2\xe1\xcd\x8ac,\xcb\x18\xdb\x12\xbceq\xd4p\x18\x18\x86\xe1\x1b\x17\xc7\x96\xba\xb3ax*\x1b\x18\xbbu\xd0CA5\x1b\xa2\x85$\xd9\x034\x06V\xbaoi\x0bZ\x7f\x0fd\xaf:o\xba\xe2\xdb\xc6<\xa3\xb6_\xac\xd5j6\xb3~K\xa8Y\x0f\xdb8\x89\xb7V{\xe9\x02\x83\x11xk5T\xb4\xf0\xf4o\xad.x7\xa3\xb6\x10\x16<\x1f\xdcE\xd879\xe3.\xc2\x87\xc2n\x92!|\x9ePK\x82<\x1e\xe4\xf1 \x8f\x07y<\xc8\xe3\xb9W\x1e\x0f\xee\"l\xfb5l\x1d\x86<\x1d\xe4\xe9\x00\xf2t\x90\xa7c\xbe#O\x07y:\xc8\xd3A\x9e\xce\x8869\x18O'\x00\xb9z\xd6\xf5\xd7\x81v\x11\xba\xadN\x96\x14T\x03\x93\xea\xb0p5u\x05\x1b.\xa3\xee\xea\xafb\xc7\x172A\x90 \x12R\xde7d\x82\xd4\xfa\xfc\xfe\x17\x0e\xb7.\xac\xba\x88r\xa3\xb8Zc q#Ip\xa1\xc4\xb7p\xb2[\x10\xc1\xed\x97\x86\xd5 \"\xb2\xf9\xc6\xf0t\xd8\xd4\xddr\xd9\xc0\x91[\x8e\xa9\xa6Y\xc5\xe4\x98_\xc8|\x9eQ!\n\xec\xbf4o\xf7\xd5{z\x8eR\x0f\xa8\xbb5[|\xa8\xfeE\xba\x9a\xd95F\xcfj\x81\nXd|\xfd(\x15\xe1]\xbb~C\x1b\x82\xd5\xb4ac~\xee\xc2y\xff\xdez\x13\xdf\xb2\xb1\xcf\"@\xa8!\xb2e\xc2l\xec\xcf\x99\xef\xee\xf0\xdf\x04\xde+O\xdf\xee\xb3\xb7\x17\xa5\xf3\x0cn\xe86b%H|\x9c{\xd1\x8f\xac_S\x9b\x01\x15\x97w\xc3\x13\xd0\xf4\xd2$vj\xd0v\xda\x1eD`03\xef\xa6\xf8\x9c\x15\xf8\xdf$b\xe6F\xf9T\x8d\xd0B\xb9\x06\x9c\xcb\x85j\x84\x1b\xda\xa7i\x8b\xc6G\xec\x9bi\xba\xb9'|\xa4\xae\xd3d\x9d\x0c\xa9Z\xa7q!\xcd\xae \xae\x01y\xfd\x9enVo\x9a\x8a\xb61\xd8\xd5\xe5\x02R\xba\x90\x16\xe0L\xa4q\xf3\x9do\xa6\x01g3`LfJ\xd1\xb3-P\x12\xaf\x80l6\x8fQ\xbd^\x04{@\xc9^J\xa5j\xdd\x8f\xb9>\xe3\x02\xd4\x97\x84\xcd\x93\x98HZ\xc4]\x9cjUB;\xde\x13\x16\xa7\xf9\x9cF\x8c\x80\xce\xad\x885\xd5\x9aL\x87\x0c=\x18\\\x1f\xcf[!h|\xba\x14\x13\xa8D\xdf\x13\x0b-dT\xd8`\xb2\x1eT\xe5(T\x03m\x02f<%K\xc6\xb3\xda\xb8;\xce\xf8\x98q\x9eR\xc2zL\x91M\xe07a\xf1\xfd\xf8G\x81\x9c}\xdd\x94GB\x84_\"\xe2\x8acp+\x99\xfb\xf4-\xea\xc3\x0e\xe18HQ\x83\xc7o\x1c\xa8\x94\xe0\x837\xc2\xcb\xdb\x17\x0c8\xca\x81\x1b\x9d\x93z\xd0a\x1b\xc13{\xf0\xfe\xf5\xee\xfd\x11\xc1\x87l\xdc\x9fP\xa1\x87k\x04l\xae\xd4\xc9\x86\x0f\xd6\x08\xb5\x10\xe16\"\xf8H\x8d\xe0\x8e\xde;\xb4\xc2\x0f\xd3\x18S\xdeN\x83\xfc\xa9\x1c\xa21n\xa3\xd1\x98\xe33\xeeo$\x85\x1f\x9bq\x04\x99Z~m\x95\xf3\x1e\x0e\xcb\xd8\xefP\x80]\xce\x04\xc0#\x01z\x8d\x0c\x1e \x80G\x02 7\x00\xb9\x01\xc8\x0d@n\x00r\x03\xf6\xe5\x06\xe0\x91\x00m\xbfv.y\x91\x0b\x80\\\x00\xe4\x02 \x17\x00\xb9\x00\xc8\x05\x00\xe4\x02 \x17\xe0\x81p\x01\x1e\xd0\x91\x00\xc9\xbc\x0e$u\x1d\x07\x90\xcc+8\x9dY\xd6C2\xaf\x9f\x06p\xac\x1b\x82kO{w~\x15\xdf\xef{\xdb\xd0\x99\x0df\xf8HL\xef\xfe\xa1\xb76}\xe5^a\x97\x89A>E\xc2\x96i\xbb~\xeb\x9b\x87\\n~\x92G\xbdy\xa8E\x9d\x95\xe7\xf2AAla[\x90\x86\xbav%e\xd86\xa4\xfe(\xa8\xdb\x16~p\x91\xea\x9b\x87\xfdO\xb7@\x01\xf1\xab\x80v\xb5 \x87C~\xa1ml\xd3\x06\xb5\xb4M\x1b\x16\xf8\x0b\x00\x97\xfdOo\xf0/L}6\xe5\xa8R{\x9e\xf6\x87#\x9fJ\x18\xb0\x87a\xd0\xfa{ \xec`Mr\xa9\x12Weg\xe5\x8d|\xea\xe7\xd8l\x05v\xe7PHn~\x95\xc9-\x1e\x10\x0fx@\xbc\xfd\xe0\x01\xf1G= \xde\xb9Pcb\xc1\x85\x13\x87\xb1\xe0\xbe\xf9\x06c\xc1\x0f\xc5Q\x95\x18\x0b\xc6X0\xc6\x821\x16\x8c\xb1`\x89\xb1\xe01\xab\xfd\xf0I\x00c\xc1\x18\x0b\xc6X0\xc6\x821\x16\x8c\xb1`\xbb\x82\xc6X\xf0NqG\x8c\x05c,\xb8\xf5/\x8c\x05\x9b\xa7\x07<\x05\x14\x0f\x0c\x1e\xd00\x1e\x18lD>\xbe\xa6\xf7\xee\xcbx`\xf0Q\xd5\x8b\x07\x06\xe3\x81\xc1-\xcc\x9f\xb3\xaf\x05\xe3\"\xf8\x14a\x17$v$ K\xf9q\xa7_$\xccTZ\xb5\xa0\x01\xff\\\xc9\x97oO]\xaa\xd7\xf3y\x16\xc0\x0d\xf2S<\x05jP`,{^\x0b\xc3\x9bQ\xa6C\x93t\xeeTx\xe4\xf8u\x18=(\x14\x9b\x0b\xa4\x06u#b\xc3\xb4\xa0\x1dD\xe9\xa6\x04u 2\xc8g \x88\x9d\xe9d\xc3T\xa0\x90\x96\xb4)\x03\xda\xd3\xa6\x0c#\x01\x0d\xc6\x14\xcbO?\xddfP]6\xdd\x88\xf2:\x9f\xf5H\xf2dh?\x1d8r\xcb\xaf\x01+\xb5\x86\x11\xeba\x18\xec@0@~\xc1\xe8\xb0<\xf2\x0b\x8a$\xc8/\xa8\xc5b\x90_\x80\xfc\x02\xe4\x17 \xbf\x00\xf9\x05m\x1f\xe4\x17\xb4\xfd\xda\xb9\x9aB~\x01\xf2\x0b\x90_\x80\xfc\x02\xe4\x17 \xbf\x00\x90_\x80\xfc\x02\xe4\x17 \xbf\xe0[\xdf\xcc|\x9e\xd7\x7f\xf0r\xd8Z\x83\xdb\xf9\xbem\xdd\xf3\xb6\x1f+\xe7\xe7\x9a\xe0\\\x7ff\xef\xde\x9f\xd7\xfe\xaeTf\xe8\xe5\xb2+\xd4\xb3)\x9fT3\xd4\x8e\xf3-\x95\xd5\xac\x8f\x82\xab\xa8\xae\xe1\x15n\xcac\x1d\x97dF\xec5\xe8\x17b\xceD\"d\xfd~\xee\xcb\xb7\xa7\xa6W)CvZ\xac\x93\x86*\xd1*j]P3\xbf\xbaS]U\xb6f\xe65\xbd\xb7\x0dtk\x8b\xf9\xe0\xc1\xc5^\xba@\xa0\x10\x0f.\x86\x8a\x16\x9e\xfe\xc1\xc5\xda-\x1d\x13K7\xae0\xc6\xd2OF\x86\xa01\x96^$\xb9G\xe7_b,\x1dc\xe9\x18K\xc7X:\xc6\xd2%\xc6\xd2\xc7\xa0(\xe1\x93\x00\xc6\xd21\x96\x8e\xb1t\x8c\xa5c,\x1dc\xe9v\xf9\x8c\xb1\xf4\x9d\xe2\xb6\x18K\xc7Xz\xeb_\x18K7O\xf7\xddR\x88G\x16\x87k\x18\x8f,6\"\x1f_\xd3{\xf7e<\xb2\xf8\xa8\xea\xc5#\x8b\xf1\xc8\xe2:s\xea\xec\xab\x8e\xfc\x06\x9fU\xacc\xc9>\x81j\xder>1g\x95#\x8au C\x07\x14\xab\x8c\xfd\xc7\x8f\x9eV\x15\x18\xad\xbe-\xa3\xf9\xcd\x18\xf9\x91#\xd3a\x94\xaaP\xec-\x90N\xd5\x85x\x0dQ\xa9v\x10c\xfcq\xc4\x83\x14\xaa`)\x06\xe9S\xbb\x90\x84\xc2\xa9S#\x89S\xe1\xb4\xa9\xd1\xa4\xa9N\xca\xd4>\x84)\xa4K\xfd~\xe8R\xc7\xa6M\x8ceM ib4\xd7\x00I\x13E\x12$M\xd4\x02LH\x9a@\xd2\x04\x92&\x904\x81\xa4\x89\xb6\x0f\x92&\xda~\xed\x98\x16\x914\x81\xa4 $M i\x02I\x13H\x9a0\x8d\x8e\xa4 $M\xec\xd1&H\x9axB\xa4 \x13`\xe8\xaf\xbbNS\xa9\xb5\xfe\xc1\x1e\xbe\\\x80\x81\x9b\xa7~\xf2\xf2:a\xb2\x08 \x12\xc6r\x92N\xf5L\xa9\xd6z\xc1\xc7-\xbc\xd6/^\x15\xef\xb9E\x1d\xa8\xec\xb5y\xd0 \xa0\xcc\xd9\xcc&}q\xc2z\x9eO&f\xd8\xa7\xe5J\xc2\x80U]\xc8z\xae^\xffF\xf9\x0e\x0f\x0fn\xb4F!\xbba\xf2\xf5\x16\x1e\x83\xcf7z\x1cb\xf5c!n\xc4\xea\x8b$\x0f\x1d\xab\xefH\xf8m0\xa3.aZ\x7f\xdf1\xa6\xf7\xac\xeb\xafv\x1f\xe9\xb0\xd3`\xc2\x16i\xfd\x1c\x82\xde\xe9\xef\xd2\xbd`\x99h\xed\xe6\xb4\xc8vx\xee+2|2\x93^\x9bN+ \x02\xba\xe3.\x93]\xa9\xf4\x8eI\xae\xd1*\xc3\x9d3hr+\x9ap\xcc\xacVv$\x9c\xce\xc6\xce\x028\x9d\x15Ip:\xc3\xe9\xac\x9c\xce4\x80\x10\xbc\x94\xbb\xd2\xa9+\x13\x99a\xf2j\x02\xfa\xa2\xb0\x9b%,\xd17\x91\xfd5a\xd2\xe4\xf8df\xb2\x86:+O\x1bG\x14imV\x8f'r\x8as\xf0\xca\x9a\xcf\xf3\xf4\xd8\x14P\xd5nS}E\xff\xd0p\x0e\x18E\xde\x81;6,\x16\xf3Dcy\xaa\x98qL\xccb\x02\x9efD\xd2\xa9\x89\x1d\x1fT\xc65\xf9\x92\xac\xf3\xb5[\xcf\x9a\x12 a\xde\xdc\xaf\x8a\xdeU\xec5\xf9r\x14q\x0f$\xdd\xa8\xeb\x8d\x02\xa4K\xd8\xde\xd2-9I\xa73\xce\xe6\xf4 t\xe4B6\x95\xaf\xea\x8c\x1b\x9a\xc5\xca\xc73E\x00\x91|-\xc6I8Ky|#\xa6\x1b\x9aM\xb7\x94\x1c\x98\xad\x1c|\x9aU\xe1\xa4\x19qT\xbd@\x8b\xd3^\x97\x96_\x03\xe6\xa6 o\xd6\xd8\xf01\xae\xac\x9dG\xd0\x8f\x1d\xeb\xfe\xa1\x1f[$A?\xf6w\xee\xc7\x1a\xf7i?O\xd6\xeda\"%\x1b\xabp\xc1\xcc\x19\x99\xc6\xff:\xb5\x1b\x05\x12)@\xe43\xb1!\x9a\xd97\xd7\xbb1{\\\xdc\xa7\xe8\xde\x8e\xf1n+\xce\xad\xdb\xd3Th\xf8\xc8^\xadk\xa8\xa1\xa1=4h\xbb\xfc\x80q\xa7y\x8e\xcaz\xc8\x16\x84e\xde\xf2k\xc08\xdeq\xce\xc7\xf9\x1e\xe7{\xf3\xc1\xf9\xde\xfb\xe0|o>\xa3\xa9*\x85\xf5\xae\x8d\xde\xda\xc0/fc\x7f\xa61\x936H\x0e\xe5 \xc6\xe5\xbc\xbe\xe0\x8d\x99\xe7\x00\xfb\xbe\x9b\xdd\xa0\xd2\xf4\x1d\xb5\x0c;\xb8\xc3\xaf\x9b\xfa\xdbQo\x8a*Y\x16\xa0S\xc6\xfdT\xaf\xf8~P\xd2\x89H\x89X%ly\x18\xc7\xae \xaa\xb9\xfcm'\xe9q\xde>\xda\x94O\xd1\x89\x1b\xb4\xc4{;_\xc9\x92\xd1\xf9\xd4b%w \x9b\xf3\xbb!\x9b\x1b`\xea\xaa\x13\xda\xd8\xdd\xe5\xeb\x84M\xad`\x1b\x9a\x1dE\xaa\xf1\xbb\xcd\xe7\xfc\x8e\xc9dM\xa7\xffM\x92t:\xb74\xc3\x11R\x8d*Mw\xff\xe9Bo\"\xe3l:\xe7\xf9,\xa5Z)#J<\x8a\x1e\x1a\x92\x19\xb5\xdc\x9bX-\xbf\xb6\x8aZ\x1f\xcfEP\xc4ra\x1bF\xa7\xd8\x7f433Q\xcd\x02\xed\x14U.`\xc0C!p\xe8\x907[\xa1\xd9\xfa\xe8\x90\x97I\xd0!\x7f\xdc\x0e\xf9\xe1=55\x8b$l9M\xd8\x82\x07;l\x1f\xcdK\x97\xea\x9d\xc2m\xb39\xe9S\x854\x0e\x97\xa6fk!\x91<\x13}>\x9b\x97\xdb\x93\xf1\xd8\x94\x16\x1e\xc7@\xb5\x14\xf9{\x1eD\x9d#ZH\x92\xc9\xe9\x8a&\xcbUs\xc6\xaa\xa4\xdcE\xa6\xfeH\x9d?I\x1b \x80H\xbb\xf3\xa5\xe8\xcapG\x84\xd9bd\x8e\x05\x98\xab\x9f)\xbc\xff\xa0\x1f\xe4L\xb9\x84t>\xbe\xe2 \x9b\xd3/S{j\xe17\xac\xb8\x96\xa38\x92\x8dI\x0e\xc6\xfd6AK\x98%\x12L\xc7\x1d]C\xa3\x99i\xced2nZ\x08\xaa\xa1j\x85\x97\xda\xfb\x0c\xa9\xa5J($Yo\xbc\x86\x8d c\\o\x8av\xad\x08F\xd6\xd15\x95|=\x13\x92\xb3\xdex\xb8W\xcf\xf6\x03\xe8*I\x9b\x87\xd1\x85T\xf3nE\xf56x}\xb0\x83t\x9b\xbdumWD\xc0\x8cR\x06\xa5\xb0\xf0\xfc&IU\xb5y\xae\xb9AebA\xe5\x8b\xf1jX'B\x94\x0bJ}\x12\xe01.]\x0c\xef\xdbF \x17~\xb7\x02\xc1\xf3\xe2\xd4\x05\xa1\xba\x80;6U\xf7r\xa0\xb7\x1a\x8dJ\xd6\xb4[\x01\xad\xbfw\xae\x1dk\x07`9\x1d{\xd3\xa0\x7fI\x9c{\xfc]m\x86\xd5\xfb\xe88K$\xcf\xac\xc0I\x06irK\x19\x15\x02\xd4\x82\xec6\x91\xdb\x11w\xc0y\x06`\xc1\xddzd`Ro\xe4\xd3\xe6\xb6\x0e\xdf\x03\x170\x9d\x85Lfxa\x9b\xfe\xe0\x85m\xfb\x00\x03\xcb\xea\xb1b\xbc\xb296a\xb0T\xeb\xefb\x99nWy\x02\xeeV43{\xc1c\x9e\x99\xc7\xf3\x84-#\x96\x99\xea\x15{^\x95\xd9\xd5\xe8\x82_w\xbd\xd5\xd5\xa5\xf8\xc8\xd7\xa5\x0c\xe5~x\x80\x8cn\xa8>\"\xe2G\x92\x15\xfa\xf4w8\x03T\x0e\x866}\xc9\xeern\xd9\xdd:\x16\xb2\xf0\x1d\xf51\xc0Ee\xb9\x80\xf0\xc5\xc8U?\xc2\x17E\x92{\\\x15!|q\x04\xf8bl<\x11O\xcb\x1fh\xff\xbe\xfd\xe5\xa7\xa3\xf4\x8b\xa7\xe5\x07kz\xb7C\x0c\xf0\xb4\xfc\xfbR/\x9e\x96\xff\xbb9-\xbf\x1f\xce>\xfb\x1as&\xa6\x16\xe0\x0c>)\xdf_\x88\xfb\x9c\x84\xfaZ\xd8\xd0Kc},\xa4\xc5P\xbd\xbau\x83\xdc~\xaaG\x8dq\xdf\x92t\xea+\xbc\xd3\xb3s\xab\x88\xfa\x0b](\x83]3\xd1\xb92M]\x1a\xf6\x0b\x18v\xfc\x86*\xa3\xd3\x0cC\xe1\xa1\xeeX\x903\xd6\x19U\x0f\x83\xc0w\x90%t\x15\x7f\x14\xf0\xbb\xab\xba\x81\xc0\xf7\x11\xab\xbb\x1f\xe4\xddU\xaf@\xb8{\x87z\x0dC\xdd\x87\x04\xba\xbba\xa6\x00\x90;\x18\xe2\x1e\x01p\xdf'\xbc\xddU\xf9\xb1\xd0\xf6\x0e\xad\x1c\xda{\x8f\x01j\xef\x0c\xa0\xdd;\x9c\xbd\x07\x88\xb5#\x86\x85\x10\xd6\xc9H\xe4\x07!\xac\" BX\x9d\x16-\xd0kz\\\x10\x96\xbf\x02\x19\\\x8d\x96I\x9dIr\x7f\x16\xb4\xf8\x9a\xab\xdc\xbe\xba{\xf4\xa7\x18\n\xa9\x0f\x9e/\x96us\x9a\xd2\xa5^M\x89\xb3\xaf\xf6\x0f\x9eie\x05/\xeb\xde\xba\xd7\xde\x96\x99\x95\x9b 5&R\xfe\xae\xf7\x11\x9a\x05^Q\x9ck\x8c\xbe\xcd\x83m\x85<\x99\xf5^\xa9\xa0iW=\x8a\xb4\x0f\xcb\x14\x96\x92\x87Y\xaa\xde2!\xb8\\\xf0\xca\xb6\xddu\x88i\x05\x83\xa3\xb1\x91:\xcchB\x9f\x15W\x9f\x93\xc27{\xe8\x82\x8a\x15\xc9\x06\xf5\x1e<\xb5A\xe7\x8c\x02\xfd\x92\xd4\x87g9\xe4\xeb\xc4\xf2\x19g\xf6> \xc9o(\x13\xb0\xa2\xa9>\xb7\x9c0 \xb1\xf6\xd8-\x8c\x171~\xc7\xcc\x99\xe6\x9c\xd1\xd2\xf6\xd8\xfb1\xf4M(\xfc\xce`\x8d\x9c\xd1\x88\x15\xad\xb9\xc3\x0d\x153\x92\x12\xd6\xbb \xf7hc\xa5\xff<\x1b\x9blD\xc3\xf6v$\xb2V\xaa?hy\x87\xe8Hox\xc2\xbc5\x93\xee3\xf6|u\xd0\x1ar\xa8\xb1\xea\x13\xaa\x0b\xe9jh\x12\xc1\xbb\xf7\xd7\x17\xe7\xfa\x12#\xf3\xa3=\x82=\xd1\x97h\\2\x87\xe7\x14\xd7\x9aT\xce\xf26k\x9a\x88)\x1f\x83\xc8<\xa3\x02\x9c\xd7\xa0:\xe4\x92/\xb9>Z\xfb8\x97~\x94\xc3\xc7_\x97\xa9\xf2oI\xaaCD\x1c\xbc!F\xbf\xc4tc\xe3N\x89\xf4.\x0b\x01\xdb{\xf59\xfb\xfe\xb1\xe4\xc6l8\x0d\x08X\xf3\x8c\x82\xc8\x13Y\x00\xf2q\xaacQ\xc5\xe46\x82=U\xabL\xdbTY6i\x9aj\xb5{\x0e\xc7w%\xc3\xaa\x1c\xf4m\xab\xdd\x96E\xc90\xbf\xaa\xb1\xcd\xbf\x88;T\x0f\xb2\xf2\xc3\x11\xfe\x82\xf8\xc8\x9b\xfe\x91\xb6\x05Z$\xa4m\xb5\x0d\xb7\xe6\x18\xa8\xfd\xd2D|\xdaN?h\xf3\xccC\xcfBh]:\xe0\xc9\x08}S\"\xc2@\x0fe\xed\x830P\x88\x0dy\xd6\xf5\xd7a`\xa0\xea\"p\x00\x08\xaa&\xae\xcc\xd1\x0d0\xa2D\x86\xba\x8fH\xb8G8\xe8tX\x15H\xea\xba7\xfd\"\xa9+X\xd3{\xb3\x8e\x90\xd4uT\xf5\"\xa9\xeb\xf7C\xeaj\x07\xffy\xd6\xc4\xfe\xcf2\xea-\xa2=\xf7\xa37\x12\xf0\xc1\x7f\xa9\x08\x01T\xb2*\xf9]\x01\xa0\x7f%??\xdd\xa3F\xfb}}<6\xbc\xdf\x97=\xcc)=,\x8a\xf9\xe8\x10\x7f\x91\xc5\x8fG\xd8\xb9\x90\x0f]X\xcad6\xdcS\x82\xc6\x8d\x97\xb8\x7f\x04y \x83{\xb5M\x1f\xdc\xb7m\xfa8\xa3\xc6.\x0c\x92\x14+\xaf\x8dj\x0b\xfbN\x9d\x0f5\xf8No\xc3\x98\xcfI\xcc\xd7\x9b\x94\xea\x1a\x0c\x9cWTym?\xf9K\xd6\xde\xe0{!u\xd0W\xea\x93t\x1a\x12\xac\xf1^\x0b[\xe8\x97\x9f\x10Q\x0c\xb2\xae\xc6\xe5\xd1\xa4\x18H1(e}v\xf5\xe7\xec\x0b&\xb3\xad\x17p\xf1g\x0f0C\xc8\x84_2\x9a\xd2[\xc2$\xac\xa9$s\"Ig$\xc4|\xfa\xa4>H\xa4\xc8\xafE\xf5f\xdd4\x11\xd2\x84\x136$\x93I\x9c\xa7$+\xd1\x83\xef|w\x87-u\x80RDl\x91\xf1u\xf5\x0d\xc1\xf3,\xa6\x1eSR\xaf-*Y\n\xe9\xfc\xdd}B\x8e!\x063\xd8X\x06\x19\xca1Fr\x8c\x81\xac:N\xaa^}\x81\x8d\xe2\xad\x11\xd2\xc0H\x89\x00M\xf6\x8e\xf2\xa3\xc9.\xdf\x18-\xc5\xe34\xd9\x03.Xx\xd3\x8dRX\xefL\xd1k\x99\x86\x94\xd4\x1dL'\xd0\xd4h5\xaa\x1e\xb1fX\xbd~\xd9whT=b\xfdau\xf3\xe9\xd2\xc3^\xcc\x02\xbf\x9a\xa1\xea\xa8iB\x80\x9d\xa0\n\x95\x1c_#-Q\x8bf}1\xfa\xef\xa7\xc3\xe8?F\xff[\xa3\xff\x15\x88.4\xec_\xc5 1\xde\xdf7\x99a\xbc\xff\xa1`\x9f\x12\xe3\xfd\x01V\xe3Y\xd7_\x18\xef?pt\x0e\xf3\xe46\x99\x9bS\xa7\xa5>\x9f:\xcb(\x93U\xfdL\xe0o\xfe\xb9\xe7\x064-UD\xe7@\\\xb8UIA\x0b9\xd6y*\x93M\x9a\x98\xfc\xaby\xb6\xf5\xbe\xd6>V\xefa\x1e\x88\xe1\x1b\xb1\x8a\xf2\xf0\x94gd! \x0ba\xd7xa\xbdz\xad,\x84\x16\xf4/\x94{\xd0\x06S\"\xe3\xa0obn3S\xc88(\x92\xdc#\xd0*\x91q\x10`A\x9eu\xfd\x85\x8c\x83\xe3E\xc4\x91qp\\\xfd\"\xe3 X\xd3{\x87\xc4\x91qpT\xf5\"\xe3\x00\x19\x07\xbd\x8c\x83\xb3\xaf\xd5\xedM\xe3\xef~,\x81 \xc7@\xf0w\x0et\x90\x0f\xca$\x1b\x92dA\xbb\xf6\x8ar\xfc\xc4O\x83{\x10\x08?\xdc6 \xb7\x06\x1e\xa25~d\xd4a\x04\x05!\xd4y\x0dr]\xbb\x96\xff#\xa8\x07A\xfezW9\x83\xa4\x83\x01\xab\xe0%\x0c$\x1ctI2H6\x08Z\x17\x02\x84\xac\x0d\xa1\x17x\x19 \x19\xec\xa5\xef\x11\xf4\x82=\xcb !\x16\x84\x0c\x1f\x08\x1cB:]\x18\xa5 \xa8f\xd0\xb7\xc6\x0c'\x13\x1c\xa4\xac0\x1a\xc1A\x8a\x1aI 8H\x99a\xd4\x81\xf0\xa2:\x9et#\x06\x07\xa7\x0ct\x0d\x8b\x11t\x81\x1d\xcc|\x0fU`X\xa0\x81@\xe2\x0e\xe2\x0c\x04\x0f\xbb\xa7\x9e\x00z\xc0\xc1-\xc7Hb@h\xf90B\x06\x9d60\x1e\x1e<\x18\xa0\x7f\xec\x01\x8c#\x03\x1c\xbc\xdcq4\x80q\xc5\xf7<\xed\x15\xed!\x84\xff\xfb\xecex\xe8?t\xd4\xc2\xa8\x91\x0b\x870\xb2G \xf8w\xd9\x94q\xc1\xfe\xa0^\xb6#\xb8\xdbX\xd0\x84\x85\x87\x8a\xe8\xd0\xb8\xd0\x10F\x86z\xdb\x11#C\x18\x19\xaa% 6\x98A\xcbk\x8c\x0c=\xd2\xc8\xd0\xa8\xe3.\xc7\x1eu\xf9\x80TQ|?*l\xbaJ\x84\xe4Y\x12\x93t\x9a\xb0\x05?\xfbjV?\xc1\xb8\xe8\x9f\x8b\xf7/\xd9\x82\x17\x98\xa8Rp\x99u\x1d\x185e\xf4\xc1\xa0\xd5l\x9f\x0c\x04\xaaT\xd2e\xf5k\xa2\xaa\xa4\x95\xfeZW\xa7\x8dKti\xd4\xcb9`6\x18\x92\\\xa7YQ2\xefEpBJ\x82\xc0\xd2t\xba[\x9a\x0d\x92\xd1\xc1\xa3'\xcd\x88Hb\x98\xa5<\xbe\xd1J\xea\xf7\xaa\x03\xa5\x85\x11\x12\xeb\xb4\xba\xfc\xc1dC\xb6\xa1%}_\xa4\xac\xf9\x19Z\xe3\x91\xcd\xe6\x01\x08\xd9\xf3t\xe4J\xd0\xc2\xe2\x10\x93\x8d\xcc3;j\n\xb4\x1c\xb2<\xa5f\xc9\xb2\xc9\xb8\xb2\x01 [\x02):\x8bN\xad\xff\x88W$a\xa7\x113\xf1=\x9d*M\xbdG0'\x92\x80\x90Y\x1e\x9br,{\xd7\x96`\xa3\x80d\xb3I\x93X\x9b\xb4\xefD\xc4\x84\xd4\xd1\xc4\x8c0a\xae\xf9X\x93x\x95\xb0v\xbe\xa8\xf9\xf4\xad3\xb5 \xd3\xa4\x7fO`\xb0[\xd6_\xd6 \x1e\x06#\xbbI\x18.\x06\x03b}\xdb5v\x8f`)\x11r\xaa\xbbKH\x039\xd3\xb5\xc9\xe8\xed7\xb7\\+\"V\x83\xa9\xc6\xe9\x15 \xd8!7\x9f!\xb3\xb5!\x99\x9c\n*\xa7\x83\xd3Q\xf1\xca\x08u\xc1H\x95\xe9\xf4C\x8c\xdcj\xe2\x80\x95j\xe3\xa5\xe0\x11\xe3>\x03Z\x84\x11\xad\x0d;\xb48\x8cmu\x18\x98\x0b \xa4N\xe5h\xba\"\x99\x14T\xfe\xd9t\x91\xfe\xfe\xd6\xf3\xb4\xfb\xd9\xa0\x01\xd0\x88\x99\x9c\x06\xe8x\x8cnCy\xebP\xd1\x86\x12\xc2\xccL\xc6\xc0\xa8 l7\xdb\xa6\xde\xee3\x865g>G\x95d\x1c\x8f\xce|v\x11h0M\x80\xc8\x0f\x81_g>\x83\xc2\x8e\xe0\xda\xd9\x17FY\x0e\xd8\xc1z\xc0`3\x8c\x9c*\x8e\xc2\xc43\x9f~K7\x8e\x95g_\n\xef\xb3\xbb\xe1\xaax$\x0f\x1e\xc9s\xa8#y\xa0\xb3\x17\xeeH\x00\xab\xf7\xdbV\xf6h\x95\xd6\x12z\xaeH\x8dc\x83\xc4\xd1>#\xd3b@\x908Z&A\xe2h\x1f\x82\x18\x86\xdb\x1d\xd4n<\xeb\xfa\xeb0\xc4Q\xbb\xf8\xab\x8d\xdd:\xd7L'*\xa7Q w\xab$^YVY\xc9\x8bl\xa1\xa1\xdd;O\xb2yD@\xf1\xfd\xa8DI\xadx\xbf\xbf\xf7\xd2\"\xafJ\xd7\xcc\xa7D\xdaL=\xcf-\xe0<\xfa+S\xb2\x97\xeeQs \x1b\x8a\xac<\xad k\x12\xc3\x8a\xa7ss\xd4\xbf\x8e\x9b\x96\xca\xd5^\\\"`\xcd\xe7yz\xec\xf3\xe7\x82\x91\x8a \xa3\xd6\x15[QK\xc6\xc1c\xfa\x01\x02\xa7.\x18\x18=\xe5\xa7O\x9e\xe1\xabW\xefI\x18\x8f\xae\xfc`dR\x9db:\xa7\x8c\xafCd\xe9\xed\x12-\xbf\x06L!\x8d!\xd8\xe6z\x1a+\x12\xear\x9a\xd4\xe8j\x8e\xf6\xd0\xd0\xd5,\x92\xa0\xab\xf9\xb8]\xcd\xc3\xbbP\x9c\xa7\xc1\x0e\x14\xe7i\xc5uR/7<\xce\xba\xc7\xa4\xdez:\x8eRU]\x95gu7I)\xa7rFo\x9b\xb6\xbc\xf7\x03\x06\xdf\x90|:\x0d\xe3rj\x80\x98\xe9`\xbc;h\xfc\xf5M\xb2\x87+d\xb7\xf1\x136\xcfr\x9e\x06\xcf\xb2\xaa\x95p\x8e\x1d;5\xe1\x1c[$\xc19\x16\xe7\xd8\xca\x1c\xdb\xbar\xec\x9di\x87\xef\xd4\xd3g \xae\x89\x8cW\xde\x8eCC\xbf\xea\x9b\x8c\xf1\xfa\xbco>fG\xf1\x1c\x0f?\xb0:G\xf9(^\xe3\xde6%\x80\xcbX\x941\xccc\x0c\xe70vK\x14\xc0]\x0c\x9a\xc9l\xd2\xc1\xf9\xcc|\xba\xe5\x19t\xab\x0e\xd0\n\xa3\xf8\x89\x07(-\x8c\x93\x186\xdc x\xc8\xe9\x94\xa1<\xc4\xc0ZB_M\x01\xc6p\x0f\x0fVb(\xdf\xf0`\x05\x8e\xe6\x18\x1e\xac\xe4P^\xe1\x98\x02;\x9f\xf5\x88r\x0c\x1ea\xf7\x00\x1a\xc5\x1f\xdci\xea\xc0\xeb\xf3\x0eisFs\x02\xc3\xa5\x80Q\x92\xe8\xd4\xc1d\xb7\x11\x83\x06\x86F*\xc0X\xee\xdfQJ\x1f\xcb\xf7\x1b+D\xef\xf3\x01\x11\x1f\x06\xbf\xaf\xdf\xde\x8e\xe1\xf5\x85\x8fp\x189\xca\xe1Pf\xfaH\x1c\xben+4\x96\xbb\x17\xd8\xff:\x96\xc9\x1d\xeb\x13\xe4\xea!W\xefP\\\xbd\xd6>\xd6y\xd2\x97\x1a^L\x12\xadZK\x180\xb8\xc6\xdc\xc34\xf0\xca\xbc2M\xa0 \x0d\xdd\x9a\x8bW\xe6AE\x0bO\xeb\xca\xbc\xa2Z\x1a\xa5\x1c\x7fG^\xeb\xd5x\x18\xf7\x08\xb2F\x18\xf7(\x92\xdc#\x86*1\xee\x11`(\x9eu\xfd\xd5\x1e\xf7\x18Kc\xb5\x80im\xec\xd6\x86\xbdI\x04\x94)cZ=\xce\xd3\x0fg\xe8H\x869\xfc\xad+\x94\xa1s\xdf\xff\xba\xa4fg\xa8t\x80\x8e\xba\xe2\xd5w\x03}\xbd\xa7\x7f\x8f\xd4/^}\x17\xac\xe9\xbd\xeff\xc3\xab\xef\x8e\xaa^\xbc\xfa\xeew{\xf5]9\xb7\xed|\xbd\xdd\x88[\xed\x1a\xe7f\x07q\x00\xfc4O\x83\x02\x10\x88\x08\xdc6\x90/\x89\xb7\xd8\x8db\x00\x04\xf9\xd6]\xe5\x0c\xc6\xfe\x07\x06\xb8\x9700\xee\xdf%\xc9`\xcc?h\x0d\x07\x10\xb2\x8e\x83^,\xe4 \x14\xca\x8e\xdcGD\xf9\xf7,'$\xbe\x1f2| p\x08\xe9ta\x91\xfd\xa0\x9aA\xdfz0<\xa6\x7f\x90\xb2\xc2\xa2\xf9\x07)jd\x1c\xff e\x86E\xf0\xc3\x8b\xeax\xd2\xbd\xba?x\xe4\xbekX\x8c\x88\xda\xef`\xe6w\xd8\x1c\x15\x1c\xad\xdfA\x1c\xbc\xc5\xce\xa6\x0d\x94A\xa7\x0d\x0cK\x07\x0f\x06\xe8\x1f{\x00\xe3b\xf2\x07/w\\4~\\\xf1=O{E{\x08Q\xf8>{\x19\x1e\x81\x0f\x1d\xb50j\xe4\xc2!\x8c\xecQ\xe2\xee]6e\\\xcc=\xa8\x97\xed\x08\xc46\x164\x1d\x11\x9b\xd1\x01\x1b\x8c\xd7\xf4\xb5\x18\xc6k0^SK\x12l\x1a\x83\x16\xd2\x8f+^S\x85\xa1\x06\x00\xc9jb\xbc\xa4m\x0c\xc0w\xe61\x8f\xbc\xee\x18\x06\xf6\xbd\xf5XK\x0e\xf7s\x1c\xa0N\xd8/\x08\xee\xf3r~2\xc8_\xa9\xe9iW=\x8a\xb4\x0f\xcb$\x069%\xa1eBp\xb9\x00\x15@h\x18y\xb4\xaf\x04\x1bN\x087\x9e0\xe8\x93W\x07\xd6\x03\x16t\x10X\xb3\xe9\xc2\xa68\xe8]\xc8\xf4\xa3*5P\xa3 !ft\x93QA\x994F\\s\x10\x0d\xb3Sc\x8f\xb0\xa2\xa9\xa6\xfe\x11\x06$\xd6\xc1\x1f\x1b\xcf\x89\x18\xbfc\x86\x16\xc8\x99w[\xe9\xa9\xa6x&\x02\x88\x10\xbc\x19{:L\x10\x0e\x1f^\xd2\xbe\x1d\xe6\x91\xe2\xef;\xae\xb5\x1b\xf3MM\x1b\xda[h\x07\xe7\xfb@:o\xd4\xe1\x01\xbf}\xdd\x16\xb19\xc4\xe6jI\x82'\xec\xc0\xe9\x1a\xb1\xb9G\x89\xcdU=\xd1\x01UT\x13\xb7y\xf1\x0fV\x15\xc5\xf7\x07\xb9p=+wp\xb4.HzW\xb3\x9f\xdc\xbb-\xcb\xda\"\xdfC\xack[\nz2\x0b\\\xa3\xa8\xc05\xadI\\\xe9\xffUE\xabnhO/\xbb\xff\xb5l\xd0\xa2-\xd4\xfe\x07Y\xff\xae\xf5\xc4\x98U\xe4\xbd\x084\xe2:\xabnwA'\xebw\x19 \xb0Ym\xca\x80\xc6\xb5)\xcd\x06\x14\xce\x86w\x9e\xd9\x17\x02\xb5jS\x07\xedB3\x9f\x9e\xb5\x96\xd9\x88\xb5I\xa9\x964`\x83\xcb\x1er\x06lr\x19\x92\xd5n\xfe\x99\x0e\xaf~\xed\x0ba\xde\x19\x0c\x16|\x8c\x02;\x9f\xf5\xad\x8dk\xe6\xad\xc5\xce_0\x99m\xcb\xf5*\xf3\xec\x9d\xe9\xdef\xed\x9a\xd1\x94\xde\x12&\xd5R\x8c\xcc\x89$ci\\-\xbf\x06\xb8\x8b\x0dk\x7f\x98\xe5e\xdb\xc4\x8a\xeb\xcc\xbe\x8e\x88\xebL\\g\xd6\x92\x04\x1b\xf6\xa0\x89\xfd\xc0\x86\xe3Y\xd7_\xb8\xce\x1c\xb3\xb8:\x1dV\x05\xae3\xefk\x9d\xd9\xb6\x94\x14\xa1k\xc9\x82\xf6\xd82\xf7\x89\x96U\xa5W\x84Y\xec\x8c\xdb\xc1\xd4V\xca\x13[R\xaa\x86x\x9c;\x99\x82\x96mCc\xa5\x922\xd0\xc2\xf7M7\xc1\xeb\xc9{\x15lx]\x19\xd4\xc86\xe1\xf0\xda2\xb4\xc1m\xda\xa0f\xb7i\xc7\xae0\xc7\xe8\xd9\xa6\x1f\xb1\xca\x1cXB\xed\xb0\xd2\xdcK\xde\xa0\xd5\xe6\xb0\xcccW\x9c\xc1\x9e\x9a\xf9\x0c\x15\x7f\xacb{\x9e\xf6/\x84\xbf\xc1\xfa\xb3'\x84\xdb\xfa{\x17\xa24,:\x08\xc93{\xdf\x9f\x9e\"E\xc2\x96\xa9\xe7\xc9|\xe7O\xa8\xea\x7f\x111s\\\x86MY\xba\x7f SuW\x1d\xf0%\xcf\xe64\xa3sH\x13!q\x0f\x11\xee!\xc2=Dac\xa0\xf6K\x18v\xd4\xeb\xb0\x86\xc2I\xfd\xbe5\x02K}\xf3\x0c\x02K\x0feq\x80\xc0R\x88Uy\xd6\xf5\x17\x02Kc\xd0\x94\xd3aU\xe0\xe6\xa2{\xd3/n.\n\xd6\xf4\xde\xbb_ps\xd1Q\xd5\x8b\x9b\x8b~7\x9b\x8b\xf2\xcd2#sZ`\xe7d\xa3o\xc5\x9bnR\xc2\xce\xbe\xaa\xbe\x11\xbco\xe8\xb5y\xf5*%%\xc3\x8a\xc0&\xa3\xb7 \xcfE\xba\x05\x9b7\xd82A\x95\xa1\x86\x8aZ\xd1\xa8\x92\xfa@q/s?\xd5\xa3\x86\xc0{1\xc4\x10\x0f\xae\x81\x15\xb6&\xaa\xd5\xda\x94\xea\x0c\xe3,\xe5\xf1\x0d\xd8\xdf\x88c\xc7k\xccB\xb5\x8eZu\xdafk\xbb\xaf\xb0\xf6K\xd8r\xd1kJ\x7fq\xe8\xa3\"m\x0bD\xbf{\xe1r\xf0d\xe4*\n\x97\x83E\x12\\\x0e\xfe\xbe\x96\x83\xfa\xff~7F%q6H\x7f\xb7>\x88\x9b\xb1\xb4-\xbc\x8f\xc5_k\xe5\x8f:\xe1\xdb{u\xf5\x84\x1f:\xd3\xbf1\xefTfz\xe9\xdd\xd1\xebO\xf0}\x93\xba\x97\xcf\x93\x99\xd4kz\xac<\xab\x07\x0b\x94\xfe\x920\xd5y\xb9\x04\x18\xa8!)\xc1\x1b\x1f\xbd\xc6+\xc0f\xd4k\xf5\x91Jo \xb99\xdc\xd6k\x02\xd7\xab\xc4x{f\x19\xe5\x16\xbb\xf6\x96g\x9bl\x0e\xb74\x13\x96#\xae~\x17|!\xefH\xa6\xd7XjPn\x81\xb0m\xc4\x94W\x9f\x90\x14\xa2\x13\xce^\xdaw\xa3\x13}\xc8:as\x01\xf3\xd9r\xbdN,@Wr\xcb \xd6\xf0\x05\xc9%_\x13\x99\xc4$U\xea\xb0\xd9K~\xffa8o6\x1d\xb3\xae\xf2's\\W\x8d]\x8e\xe0\xba\xaaH\x82\xeb\xaa\xc7\xbd\xae\xda}i\x91\xcc\xe2\xb3xE\x18\xa3i\xb9\xae0\x7f\x8b\xe05\x85M_B\x87i\xaa\xad\xd4\xe5\x8fo\xc0ef(B\xdaH\xf7\xae+\\\xd9OeQ\xd1\xa2\xcc\xca\xf3\x875:\x85\x1c\xba\xe9\xaa\x9c\xa8\xdd\xbaG\xbf\xe3\xbc}[]\xa0l\xde7\xa4\xc2\x07\x1fe\xf9\xba\xd6\xb5\x1bi>^\xbf\xbe\xbe\x98~zw\xf9\xee\xf2\xfa\xf2\xf5\xcf\x97\xffu\xf1v\xfa\xe9\xdd\xc7\xab\x8b7\x97?]^\xbc\xed\xc9\xbexY\xbd\x1a\x92\xee\xfa\xc3\xdf\xdf_]\xbc\x0bI\x1a\x9a\xee\xcd\xcf\xef?^\xbc\xed2+\x15\x0c\xa1\xfe\xf1\xa6\xf0=\x94\xd0X\x06\xea\x06u\xe1\xf4\xc4\x8e[\xdd\xac\x89PK\x1a\x1b\x9a\xd4k3\x9e\xa6\xfcN\xad\xd4t7\x10\xe7\x113\xf59\x05%\xc8)X\x85\x9d\x82\xfaW-Z*\x12\xeas_\xe0%\x0c\x08\x7f\x0eom\xccN\xcb\xe6\xbd\xa2^8\x87\xd7\x85\x80j\xf9\xf5\xdf\xca\xe3\x15\x92d\x92\x9a\xc5\x10\xdfP\xa6DTK6\xb1\"7t\xe2\xe5`\x05\xacgB\xe2\x1b\xc6\xefR:_\xdaL\x8a\x97AH\xba\x01n\x96d:fE\xb3\x0d\xc9\xe4\xd6Z7/\xef\xb6\x8c-\xaf\xb7\x9e\xeb\x04\xdeo(+\xcd%\xc9h\xc42J\xe6:V/(3k\xbb\x8c\xc64\xb9\xa5\xb0!\xf1\x0d\x95\xc2/\xcc\xe8\xbd^\x9cZ\x8bB\x9cra\x17\x87j\x81\xcb8\xa4\x9c-iV\xac\xe1]\x11\xda\xb3\xd3%D\xcc\x151~\xf6\xd5\x14N5\xae\xc3\x0c\x89[\x8e\xfb\xf6C-\x81-\x11\x94g\x903\xfb\xc7\xfd\xd9\x94\xf7\x1f\xde^|\x98\xbe{\xff\xee\"p\x14\x15\xef|z\xa7\xff\x0fK\xec\x92\xee;\xfaG\x8b[\x1f\xf4/\xa1=\x8bs\xbd~~i\xd6\xcf\xfa\x9c\x7f\xdbB\xae\x91u\x0f\xac\xd5\xfc\xdc\xf5O\xc7\x8a\x98\xd34\xb9\xd5\xad\xa9\x99\xbe[\xf3\xf6\xa9]\xae\xae\xc9\x16\xe6\xc9bA3Xd|m\xc6\xacJ\x00jEW,i\xb7pG3\xb5\xb4\xd7\xe7E\x15\xa56\xca$\x99_ \xfdBb\x99n\x1d\x14c\xf2m\xcbs|?\xf7\x07\x7f`_\xaf\xdb\x8b1\x93\xe5\xe0\x8e\x88\xb0I\xde\xa4\xe4\x99\x9c&}W[\xdb\x84\xc1\xa3\nZ:\x95*\xa5\xdbR\xdaV\xe0w\xcc,u5\x0f\x16\xb4\x19\xaa8\x13=\\\xf7\x9e\xd6\x01\xcf\xfb:BM\xcb\x16-\x1b\xb1\xbb\xaa\xbd5\xe8|\xd6\xf5\xa4\xafG2Fc\xa9\xb7\xb9\xf0M\x7f/\x08p=m\xc2Q\xfbv\x86vT\xf44X\xa9\xd44\x11\x9aMR\xd6\x07\xcc\x8d\xd6\x8b\x84f\xe2T;!\xc6\x82\x105\x93\xd9\x9e\xe4\x0c\x80\x1a\xcd\xa6-\x12\x111\xd7@\x1a \x95\x19\xb9\xa5\xe9\xf8\xa1n\xf1\xe10\x85\x0e\xf6\xa0\xb2\xa2|C~\xcd\xcbi\xcf\x16sZ^\xb4B\x96\x19\xd5\xc4\x0b\xce|L\xbc\xf0\x1b\xc6W%d\xe8\xefR\x15=\xd8\xcbV\x1a/X\xe0`\xddE\xb6\xc2\xad\x18\x16\xaf\xf5\xf7.\xf4\xb3f\xef.]\xf6s\xbb\x8e\xf5NB,\xbb\xa1\\\x15W\xeb\x90\x14\xb4\xda\xb4gf\x12D\xac\x14\xd2\x9c\x80\xd8q\x95N\x9bHM&\x9d\x19Gz\xab\xce\xbc\xb2\x18\xb7\x066i\xbb$\xbc\x0de\x1a\xdePS\xf6\x84\x92\xdb\xd5\x81\x13\xba7\x86g\xb6\x909\x0d\xf7\xca\xe8\x0f\xee\x95i\x87\xdbB\x06\x8a\xcf\x926\xb5P\x0dH\xd73:\x9f\x1b\xafu\xf9\xe1\xeaM\x89\xc6[\x18W\xc0\xddJ\xf9\x8ff\xd6\xcf\xcc\xe3\xb9\xf6\x8a3S=\x97R/\xc6\xf4Z\xcb\xaf\xbb^\xfe\xba\x14\x1f\xf9\xba\x94\xe1k\xc4\na3\xba\xa1\xfat\xdc\x1fIV\xe8\xf3\x15|\xffG/M\xa5\x02\xba/\xbd\x82\x1fT\x82\xdf\xc2\x86\xf7=1\xda\x8a\xfebz\xbf\xcfak\x91\xb3\xf6K`0\xc5\x1a\xb9Q\x91\x14g\x181\x8c\xd2\xe7\xc3a\x18\xe5\xa1\x00\xb5;\x85Qz<\xa5\x06j\xfe\xe9\xc3\xcfg\x19\x15<\xcfb\xcb\x07\xd1A\xd4\x9c%\xbf\xe6T-\xa7\x9d\x93bY\xfajL9\xc6\x07\xcd\x12\x92&\xff\xa4\xf3\x88\xe93\x97c\x9e\xc2,\xd7\xeb{\xdbn\x96Lb\xe42!j{ !\x10 )%BF\x8c3\n\xd1\xc9Yt\xa2\xfc\x94\x8c\xc4\x92f\x13}7\xe4\x86\x7f\x85\xd7\x0c\xfe|}}\x05\x7f\xba\xb8vK\xf2O\x1f~6\xfdb\xab\xcf\x14'\xf0\x8fz\x13_o7\xf4\x97\x7f\xfc\xa2\xa6T\xebw0\xa7ic\xa1t\xdd7\x19\x9f\xe71\x05\xc2\x8c\x057\xe5\x95t\x05\x83>\x11%\xbe\xf1\xfcb\x12\xab\x1e\xcb\xf9M\xbe)\xe6\xee\x19\x11\xd4\xa1\x05\xaa\xc0O\x1f~\xd6\xb9\xaf\xc8\xadV\xff\xdak\xf7\xb9ix\xe2\x84Q\xdfoy274*\xb0Y\xebn\x99\xd1\x05\xcf\xe8\xa9K\xa92 2\x99%i\"\xb7\xc0(\x9d;\xbfF\x0f\x8d\xecV\x0dPPb\xa8u\x81rfT\x07S=j\x02\xcf?\x89\x82\x14\xa5*\xa2\x1aMuz\xd3j\x84\x91\xa5\x16|\x96Q}\x80\x8f\xcba\xf2B\x1f\xe4\xce%=7\x9c\xa8E\xceb\xd35\x94\x0c\xb6\xf7\xdb\xc8Q\xba\xf5\x9dB\x0b\xcfi\xdfWy\x82\xaea\xf4\xd9\x07DP{[\x80t\x99h_J\xcf\xe2E\x87\xd2;\xda4\xd2\xaf\x16Y\x11SO&\xa6\x9d\xc9&\x11\x93\x98\xaf\xf5x\xfb\xa8\xbb\x92\xb0\x80\x93\xde}U\xeb\xe7\xf0\xdc\xba\x07f\xe7\x90\xe9{/`\xadi63\x1a1\xb3\xcdK-\xe5\x8a\xe3\xe8kt\x15A\xd7\x84\xc9$\xde\x05@?f\xf8:|\x12\xf8\xabe\x0e\xd9\xc3\x8f<\xbb\x0eu\xb3\xeeH\xb73~K\x9d\nl\xb7\x19{Rb\xd8J\xfb\xf3k\xb6\xfd\xec]\\\xcb\x80d\xb3Df\xaa\xdf\xf7\xc8\xe9\xec\x8dE\x8d\xf4R\xe9\xa2\xae\xf9\xf3\x7fQ\xa9^\x94\xcb\x98\"\xe5o\xbe\x94?\x0cH\xf9\x17rKB\xc4\x84WzZS\x19\xf4\x8a\x97\x88\xe7?q>\x89S\"\x84/\x9d\xc9V\xa50Rx\xa9\xfe\xe8\x89\x0dN\xee\x7f\x1f\x90\xfbj+W\x9c\x15\x92\x9b\xec\x7f\xe2\xfc\xf9d\xa2L\xa4U\xa9\x91\xfa\xf9\x8b\xaa\x8eu\x05\x9a\xf2\xab\xc7\x97F\xfc\xb7\x17\x1f\xdf|\xb8\xbc\xba~\xff\xe1\xc5\xb9\xabA\xa9|\xef}\x9b\x83'\xf8\x7f\x0c\x08\xfe'\xeed\xd6B\x9f\xbf\x82\x7f\xd9\xcc&?q\xfeu2\x99\xfcf\x9f\x10\xb6=U\xd3\x9fz\xbc1\x13\xc6_I&V$U\xd5\xf1\x8a/\xe4\xafg\xe6rJ\x16\xb5|>\xb1u\x99\x93.G7\xa7N\xf5?^\x01KRoe\\f\xaf[\xe7ze\xe2\xa2\xc5\xf8p\x8e\x02\xcc\xb6\xb0\xa9\x8fTC\xc3\xdd\x16\xbbAsA#\xf6]\xcb\x94q\xa6|\xc7\x89~\xa0f\xc0\xef\x94\x83R\x98\x07e:\x1c\xe7\xd6\xe83b\xc5\xf0\xb4,Khs@\x8b\x19\xd5\xa31k\xbf\xf6\xbb\xb3\xef\xf4\xed\xdb~\x11\xc6M\xa3\xb6\x0d\xa3\x93\x05\xe7\x93\x19\xc9\xb4t_\xce\xb6\x93\x7fF'\xa6>\xc6\xbb1\x9e\x97\xce<:\xd1Ou'\x88\xd8_>\xbe\x7f\x17\xb1W\xaf^\xbd2\xdaR\x7f\x97\x9e\xb2\x99\xc0\xb8\xeaj`\xec\xabq\x84rA\xdd\nz\x99\xa7$\x8bX\xf3\x15\xa9\x8f0,\xad\xe4i\x89\x9d\xd8\xdeuj\xcd-\x8b\x98g\xd4\xcc\x15/\x9f\xff\x8f\x12\xf9\xb3\xf5A\x0b\xab\xee\xab`\xe2\xba\xf0\xb9\xeb\xa0J\xd9\xaa\xd7\x96\x8e\xdc\"I\xa9\x1d\xae\xaeK_\xd1LpV\xf6\x19\xbb\xe2\xd0\x94\xf2\xa9\xd6\x90\x8f\xa3\xd8\xa7\xaa\x1d\xdc\xc3\x1f*\xe3\x1f\xa0\xcc*:\xd1RG'\xe7\x10\x9d\xb4\xf5\x9b\xaa`\x13#JtrZf\xa0\xc5xG\xd6:\x93\xffeJ\xff\xdf\xdes%H\xfd\xb1'\xce\xe5\xc2\xfa(UM\x1b\x9d%\x02\xeeh\x9a\xbe\xbca\xfc\xce\xdc\xb6\xa3i\x0d\xee\xbe\x1c\xd3\x15\xaa\x0dyjf\xc1Z\xeb:\xbezQ\x8cj>\xb6\x04b\x1a/b\x9fu7q\xad\xb7\xe2\xe9\xbcr3\x8f\xeed\xb5\xeb\xe4\xd5c\xdb\xe8\x11\xd3\xd9\x14\xed\x0b\xcfU_wUi\xb8\xe9n%\xf6\xcb?~yq\xbeO\x9bT\xb3\xab4\x8b\xae\x8f\xc9\xe3\xfb\xc9\x0f\xdf\xff \xa2\x13\xab\xf5V \xbe\x89.<\xeb\xfb{\x98\xce7v\x9b\x14\x1e\x151\xe0\x0f\xe3Q\x11\xdf@\xd3{\x9fe\x80GE\x1cU\xbdxT\xc4\xd3?*\xa2\x8f\xde}\xf6\xb5\x0c\xb8\xffv\xa6\x16\xab\xe2\xec\xab%\x07\x04\x9f\x1c\xe1\xe2\xdc\x05\xf5\x9bi\xd6\xf7\x1b\xc7\xdc\xf1j\xd1\xce\xf4\xf6S<\x05\xa2\xf7`p\xdc\xf1\x00\xda.\xbdt1C\x8f\xeb\xd2\x11F\x1b\x0e%\x0c \xac\xd3\x0c\xf1\xbd\x0f\xc0\xf6\x0eE\xaa\x86Y\x99\xfbP\x9c\x83X\xde\xc1\x1c\xef0\x86w\x10\xbf\xbb\x93\xdfy\x08n72\xbb\x91\xd9=\x9a\xd9\xdd\x85\xc0\x06\xb0\xba\x0f\xcb\xe9>\xa0\xe5\x18O\x8f\x0e\xe7r\x871\xb9\x83\xc6\xf9H1\x91\xc3\x1d\xc6\xe1\xee\xea\xd1\x81\xfc\xed=\xd8\xdb!\x135\x04N\xd6&]\x00y3|\xe4@K'::g\xbb\x8f\x00\x1cH\x01\x1dY\xc3Cq\xb5;\xf9\xd8#{](G;\x80s\xa2\x93\x0d\xf3\xb3\x07 1\xe6\xd3\x1d\x91\xfc\xb6\xcc\xec.U\x0e\xb3\xb2C\xfb\xc9\xd1\x19\xd9;3\x13\xebL\xe2M\xb2\xa1i\xc2\xa8\x0b (\xc3\xf8\x92\xb3\xd8y\x0e\xcelnaF\xe5\x9d\xf2\x11\\H:bk>\xcfS\xaa\x96\xcb \xe8\x86d\xca\x1b\xd4\x14<\xdd\xf1\x85\xab\xa4\xf6\x92,\x0dG\xbb\x84T\xbb\x17\x1b\xbd\"\xe7\x8b\x88)\x8fB\xdf\xce\xef\xac\xb5\x1eO\xf5t\xd6\xe1\xf0\x12\x86R\x8d3\xce\x17C<\xac0*bg\xc8\xbbl\xf05\xcdnR\n\xbaP%5\xfd\x92\x08IY\xdc\xd2\x90\x9d\xc2N\xf5\xf1Q{H\xdc.\x8d\xceu\x84\x14\x87$q\xf60\x7fKi[O\x1f\xd4\xa2\xdf\x11\x01\x19\x95YBo\xe9\xfc\xc0\xd4\xce\x1d\x98\x9d>\xb13b?R\xa1\x83\xf4*\xd9\x9brN\xd0\xc7\xf3X\xa4\xca\x1c\x80\xc9u4\xcc:\xf4\xa6\xae\xda\xbb)j\xaby*\xf5\xea\"u4\xac\xd3\"u\xb4H\x82\xd4Q\xfd\x1d\xa9\xa3H\x1dE\xea(RG\x91:\x8a\xd4Q\xa4\x8e\"u\x14\x00\xa9\xa3H\x1dE\xea(RG\x91:\x8a\xd4Q\xa4\x8e>k\xfb\xbe\x0fu\xd4\x0b\xb8\xd4p\xa4:\x07\xcc\xc2df\x15\xef\x1f\xa4Q{\xef\x08\xc7\xe9\x9f\x0e\xd7\xc3\xc5\xc5\xfa+\xa1\xdd\xaaoQ\x83\xe2\xfb7\xa6u\x9d\xc5iB\x99\x9c\xd6y?!\x1c\xaf7\xfaUC!qt/\x87\xb5\x9al-9\xa8\xf8\xb1\xc1t\x8aXAu*&\xd8\x82\x1dPF\x91\x02hc\x9e0~\xe2G\xcd +40\x9fv4S%y\x19\xd5\xf4\x95\xdfF+\x8b\x1bT;?\x9bahqHr\x9d\xc6\x8a\xdc\x1b\xb9\x0d]z6\xea6tnOg\xacuX\x8f\xd0\xa9\xcb\xfb\x8b\xea\xcb\x10H6\\}\xd0\xda\xb9\x11\x96EX\x16aY\x84e\x11\x96=\x1a,\xdbOn\x1a\x86fG\x9a\xf8`x\xf6\xde\x01\xda]\xce\xaeD\x98\x16aZ\x84i\x11\xa6E\x98\x16aZ\xd3\xe8\x08\xd3\"L\xbbG\x9b\x1c\x0c\xa6\xdd\x83\xbd\xeb\x9d\x08\xec\xc1g\xde\xa9\xc0>vS?\x1a\xb8\x01~\x98\xf6@\x16-\xb2h\xcdg\x98E[\x94\xe1\xf3g\xbd\xaeX\xa7\xd2~h\xa3\xd2F\xccpi;\xf2\xf0\xb8\xb5H|\x0d\xeagH|-\x92 \xf1\x15\x11VDX\x11aE\x84\x15\x11\xd6\x00\x84\x15\x89\xafm\xbfvL\x8b\x88\xa8\"\xa2\x8a\x88*\"\xaa\x88\xa8\"\xa2j\x1a\x1d\x11UDT\xf7h\x93\x83!\xaaH|-\x9fJ$\xbe\xde\x07\xf1\x953A\x99\xc8\x85!\x03\x9e}5\xa0\xeb\xd8\x83\x0e\xdf\xb8l:x\xb0\xeeq;\x156bm\xf4\xcc}\xa9\xb0\x15\x91\x9e\x0c\x1b\xb6\xd6`\xc3,\xd8\x9a\xea\xbf\x19\x11V\x0e\xc3\x8c\xa1+Q\x84\x18\x11bD\x88\x11!F\x84\x18\xef\x0db\xec\xd8\x9bb\xcd\x85\xf6\xc6*\xa9L\x8b+d]\xe6z~%\xb0Ln\xcb\xfbg\xfb\x08\xa5-\x85\xf8\xa9\x1f5\x9d\xb4\xa2\xf5\xa9\xd5\xd4\x10*z\xc0\x08\x82n\xa0\xa2a\\K\x99\x8b\xef\xc3\x90\\\x8c\x16a\xb4\xa8\x16-*\x07k\xfdB(L\xd4\x99\x8f\x03\xad\x9b;l\xa76?\xa5\xdd\xd9au\xef\x99\xeb\xe3\x8a\xda0\x92;\x08\xdb\xb2}\xae%U\xb8\xa8A1)\x9b\xb6\xdfj\xeeP\x195\xd2\x0f_\x91\x91\xb0J\xc3\x02\xd98wWmZ\x7f\x0f\x84I\x8aH[i\xa0*\xf1\xb5%eT$\x16\x94eTY\x1b\x8b1\xba0\x98\xf6\x1cu\x98>b.\"m\x02v\xed\xc0V\x8b7\xd4\x14\xf5dC\x96 #V\xcav\xd3R\x86\xa3]\xd2\xaeh\x99{c\xd8\x94\x84\x18\x12\xb3\x7f\xf1\x86n\x87\xc2/\x01\xdd$\xb4\x93T7/\xaa\xc2\xdd\xfe2\xf5\xd5b\xb6D\x08\x03)_\x91%\xfd`\"\xf1\x13\xf3\nW\xbdh?\xe9\xa3fp\x15\xb5?~\xd8\xa9\x17)\xec5g\xee\xd3\x1eY/b\xb2i\"\xb45)\xbbA\x8d\x0e\x14x\x1c\xc1S\x08M\xd7;\xec\x98\xc8t\xed]\x8cN\xdb\x87\xdd\xae\xb9\xf9`t\xfa\x10f\x02\xa3\xd3\x18\x9d\xc6\xe84F\xa71:\x8d\xd1\xe9\xd6\x0fF\xa7\x1b\x1f\x8cNct\x1a\xa3\xd3\x18\x9d\xc6\xe84F\xa71:\x8d\xd1i\x8cNct\xfa!\xd6\xa0;j0\x18\xdc3\xd0n\x03\xd0=p\xbd\xda\xe0\xabN\xe0jh\x951\x80i\xd7|\xf9\x93\x98\xa7)\xd5\xbe\xedO\xc5{\xb1\xb8\xadK\xb3N\xd8\xa5\x15\xe8\xfb\x91\xfa\xaf\xc7b\x06\x94\xbeH\xc9\xd2\x85\xf4\x94IK\x16v\x9e\x93y\xc6\xca\xcdr\x9b\xe6vy\x9e\x95;A\xbb\n\xdb\xb7\xa9\x9e^Pm\xc7\xa3\xb3\xbd}\xbb]\xa7f76\x12{\xb5\x1f8\xac\xe0\xc9D\xbaJ\x1d\x0ca\xd8a\x91\x9d\x80\x93\xa67xL6\x1e\x93}\x0f\xc7d\x97\xa3u\xec \xd9\xd6@D\xec\x00'd\x975T\x9e3\x9e\x90=&\xba\x86a\xc2\" \x86 \x01\xc3\x84\x18&\xc40!\x86 1L\x88aB\x0c\x13b\x98\x10\xc3\x84\x80aB\x0c\x13b\x98\x10\xc3\x84\x18&\xc40a\xfd/\x0c\x13\xc2\x93\n\x13\xe2 \xd9:Q{t\x893f\x82\x84\xe2\xeck\xf9\xc7oE\xd8)4v\xf4\xa6x\xf7\x8d}\xb3\x8c\x1e\xd9\xedT.\xcb\xe6\x0e*(K\x8e\x18e\xf3\xbe\x80R\xb3\xa0\xa7\x13Rj\xea\xbc\xf2\\>(\xb4SH\"\x87\xd6\xc3.\xb8`\xc1\x05\xd0\xef8\xd7\xc4\x19>\xca\xea\xd6\xa5\x9aI\xf0\xa2\x9a\xb2|]\x1b\x1a\x8d4\x1f\xaf___L?\xbd\xbb|wy}\xf9\xfa\xe7\xcb\xff\xbax;\xfd\xf4\xee\xe3\xd5\xc5\x9b\xcb\x9f./\xde\xf6d_\xbc\xac^\x0dIw\xfd\xe1\xef\xef\xaf.\xde\x85$\x0dM\xf7\xe6\xe7\xf7\x1f/\xdev-\xde+\x86\xa2\xfe\xf1B\"{(\xa1>d>\xea\x06u\xd1!\xb5\"*\x9a5\xd1\xabi\xbb\x83\xdc,\xaa\xd3\x94\xdf)/Ew\x03q\x1e1S\x9fSP\x82\x9c\x82U\xd8)\xa8\x7f\xd5B\xbb\"\xa1Y3\xbd\x84\x01\xe1\xcf\xe1\xad]H\xfd\x8e\xa6s\xa1Z\xa6\x9c\xd9?\xee\xcf\xa6\xbc\xff\xf0\xf6\xe2\xc3\xf4\xdd\xfbw\x17\x81\xa3\xa8x\xe7\xd3;\xfd\x7fXb\x97t\xdf\xd1?Z\xdc\xfa\xa0\x7f \xedY\x9c\xc3?i\xc6_\x9a\x05\xaaZ0\xb8\x16r\x8d\xac{`\xad\xe6\xe7\xc5\xc6j{x\xc5\x9c\xa6\xc9\xadnM\xb5>a[\xf3\xf6\xa9]\xc9\xac\xc9\x16\xe6\x89\xc6\x0d\x17\x19_\x9b1\xab\x12\xe8@Q\x11<\xde\xc2\x1d\xcd\xa8\xea\xa8r\xe2\x95\xda(\x93d~\x81\xf4\x0b\x89e\xba-po\x9do[\x9e\xe3\xfb\xb9?\xf8\x03\xfbz\xdd^\x8c\x99,{'x\x08\x9e\xe4M\xca\x80K.`\xd4\xa8\x82\x96N\xa5W\x10\x9d\x96\xd2\xb6\x02\xbf\xb3\x08\x84\x89\x12h3Tq&:-\x10\xf4\xb5\x0e@\xf8\x1d\x190\xbe\xa6e\x8b\x96\x8d\xd8]\xd5\xde\x1at>\xebz\xd2\xd7#\x9d#=]\xf1M\x7f/\x08p=m\xc2~\x07\xd4&\xea^\xcfU?=\x0d\xd6\xdc\xa6_\xd6\xc7[\x81\x8aS\xed\x84\x18\x0bb\x03\x0c\xba'9\x03 t\xb8\x9a\xe9\xc0Xy\x90\x83\x86WdFni:~\xa8\xdb\x08]\x98B\x07{PYQ\xbe!jy\xedd\xb4\xc58\xc3\x98\x08 \xcb\x8c\xd29\xe4\x1b\xce`\x9eg\xee<\xa5\xc2o\x18_\x95\x90\xa1\xbfKUj7\xda\x8c\x17,p\xb0\xee\"[\xe1V\x0c\x8b\xd7\xfa{`\xb0\xec\xd2e?\xb7\xeb\xd8\xc2\x8b.]h\xb3:.\x81Y\xad6\xed\x99\x99\x04\x11+\x85\xb4\xd4\xbf\xf6\x1bR\xdaD\xea\xe2D\x07-\xd3[\x8ai\xe5\xcb\xe1\xa5+\x95tx\xe9JE\x0bx\xe9\n^\xba\xf2\xadO\xb6i\xe2\x89\xf5\xb3m\x8a\xbfe\xcb\xe16\x1dy\xe0\xc96}\xfe\x1dRV\x1f\n\x88+\x91\xb2\x8a\x94U\xa4\xac\"e\x15)\xab\x12)\xabHYE\xca*RV\x91\xb2\x8a\x94U\xa4\xac\"e\x15\x90\xb2\x8a\x94\xd5\xc16yJ\x94\xd5\x02\xc6\xaa\xe3H\x8dc\xfb\x8bP\xdb\x03\xe5|\xe2\xc5%\xe1\xccS\xbc\xb8\xc4\x88||M\xef}\xb3\x06^\\rT\xf5\xe2\xc5%\xbf\x93\x8bK\xf4 &% ^\xff95\xacT\x0f.\xe9'\xbc\xeb\x974\xc7\xb4Iu\xbf\xfc\xf1\x0d\xa4\x1a\xe41y\xeb56\xb1\xa4O\xaf\xfa\x0dr\xbb\x97\xa9\x9f\xecq\xd3\xda;\xd4[I$\x1fTX\xc4\x8a|\x0cv\x899<'\x80\\\xd2\x95[E\x9f\x03\xf2\xd5J5\xaf\xf4\x89\x19\xa2C\x08\xd6#@h\x88 F\xa9\x13Z{9\x86\x9a0\xd4\x84\xa1&\x0c5a\xa8\xe9h\xa1&\xe8\x9b\x98\xd4' \xe4\x04\xe3M}p\xe8 Z&\x86#\x87\x9f\xa03\x04\x05\xfd\xca\xc2P\x14\x86\xa20\x14\x85\xa1(\x0cEa(\nCQ\x18\x8az@\xa1(\xd8\x97V\xe3mn)\x11-\x7f\x83\x8b\x87G4v\xb94 \x12\xd3*\xfb\xefl\xb1\x87\x98W\x90\xbbr\xfb`\x82\x9bZ\xaa\xe9\x02\xbdn\xdc\xd4\x02\x15-\xe0\xa6\x96G\xb4\xa9\xa5\xf6Ks\xb3HM;f\xbb\x87g@\x9a\x17!\xb7l\x16\x01\xb3W\xa4bx>\\\xbdq~\xd5\x04\xb7\x88\x04\x19^\xdc\"R$\xb9\xc7X\x88\x0c\xc1\xefC\x0d*\xe2\xf6\x88\xdb#n\x8f\xb8=\xe2\xf6\xf7\x8a\xdb\xe3\x16\x91\xb6_\xc3\xd6\xb2\x88\xcb#.\x0f\x88\xcb#.o\xbe#.\x8f\xb8<\xe2\xf2\x88\xcb\x8fh\x93\x83\xe1\xf2\xdf~\x8b\x08\xee\xab\x08\xa7\xa3\xe3\xbe\n#\xf2\xf15\xbd7\xf1\x1f\xf7U\x1cU\xbd\xb8\xaf\x02\xf7U\x9c}-H\xf5\xc1\x17R\xfb\xc1\xe3b\x8b\x05k\xec\xae\x08\xdcQ\xe1\xa7z2\x1b*\x06C\xd0\x95P{\xdf\xd5\xd1\x9d[8]\x8e\xc31\x85!\xc9\x8b|\x06\xe2 \xa1\x90\x13\xc6\x120\x96\x80\xb1\x04\x8c%`,\xe1\xdeb ]\xa0\xf9P\x1c!\xd8\xa4\x07\xc6\x10\xee5\x82\xb03\x99\x06c\x07\x18;\x00\x8c\x1d`\xec\xc0|\xc7\xd8\x01\xc6\x0e0v\x80\xb1\x83\x11mr\xa0\xd8A+\x8f=\xe3|1\xc4A\xecq\xd7B\\\xb5\x12\x87X\xd3\xec&U><\xd7\xf81\xd0/\x89\x90\xfa\xa2\xcdpa\xa7\xfa\x18\xa9=$n\x97F\xe7:B\x8aC\x1e{\xdfC+/\xa55\x05\x02\x91\xe5eTV\xf4;\" \xa32K\xe8-\x9d\x1f\x81\xdf\xbc#\xbd\xb9\xc2n\x86\x1f\xa9\xd0\xce\xa6\x1em\x1e\x1cu\xaa\xd7E\x06\xaeUc\xdeT\xc9\xcdS\xb6\xd2\x8b\x8c\xaf\xbd\x8b\xbd\xda\xea\x8d\xfc\xe9\xb0\xde\x8b\xfc\xe9\" \xf2\xa7\x011O\xc4<\x11\xf3D\xcc\x131\xcf!\xcc\x13\xf9\xd3\xad\xbf#\x7f\x1a1P\xc4@\x11\x03E\x0c\x141P\xc4@\x11\x03}\xe8\x18\xe8C\xe0O\x97\x07\xcb\xd6`\xa4:\x0f\xd2gm}\x8b3\xf6\x8b\xef\xc7c\x07r&(\x13\xb9\xd8\x87 \xe8\xf2\xe88\x87\xb9(\xa3\x83\xffF`\x99\xdcR\x16\xc2#\xac\x96\xf4t\xb8\x84\xb5V@L\x0d15\xc4\xd4\x10SCL\x0d15\xc4\xd4\x10SCL\x0d15\xc4\xd4\x10SCL\x0d15\xd8\x11\xbfAL\xed)cj\xadX@\xb9\xfd\xb0\x8a\xc0\x88\xd6-\x88}\xb7!\xe1 \xbc\x83\xbe+\x9e\xc0\x0b\x15-\xe0 \xbcO\xe9\x04\xde\xa2Y\x0d7\xb5\x8a\xc3\x8e\xe2\xa7\xd6\xc0b\xa5D\xe3\xac \x7f4\xc8\xec\"\x7f\xb4H\x82X7 \xd6\x8dX7b\xdd\x88u#\xd6\x8dX7b\xdd\x88u#\xd6\x0d\x88u#\xd6\x8dX7b\xdd\x88u?Q\xac\xbb\x89.<\xeb\xfb\xfb\x9b\xf3G\xef\x952z:,>\x1e\x1f<\xe0\xce\xe3\xf1\xc1\xdf@\xd3{\x9fo\x8b\xc7\x07\x1fU\xbdx|\xf0\xef\xf3\xf8\xe0\x9e\x0d\x02g_\xcd\xf1 ;\xee\x14(7\n\x04l\x11\xa8\x9e\xa0+\x8bM\x03F\x82\xf0M\x03~\xc2\xa7\xb4g`0\x06?\xa4bY\x9e\x0b\xe3]\xfakG\xa8\xaf\xeb\xf6X\xcc@u \xa0JE>x01\x06Y0\xc8\x82A\x16\x0c\xb2<\xb6 KW4a(\xc0\x12l\xd2\x03\x83+\xf7\x1aZ\xd9\x99c\x84A\x15\x0c\xaa\x00\x06U0\xa8b\xbecP\x05\x83*\x18T\xc1\xa0\xca\x8869PP\xa5\xf3\x94\xdd!rf\x8f\xbb\x16\xe2\xaa\xe1\xc1\xc4\x03\x9a\xfb\xd6\x07\x13\xf7\xd1\xbewg}#\xe9\xfbd$W\x1aI\xdfE\x12$}#\x1e\x89x$\xe2\x91\x88G\"\x1e9\x88G\"\xe9\xbb\xf5w$}#>\x89\xf8$\xe2\x93\x88O\">\x89\xf8$\xe2\x93\x0f\x1d\x9fD\xd2\xf7\xde\xa4\xefV\xeeV\x93\xb9Y\xe5\x88\xb5\xbft\xa0\n\xd4\x9e\xeeKUM\x89\xa4BN\x83\xeaYI\x0b\xfc\x96fYV\\\x8e\xe6\xae<3kX6/h\x8af\xf6Po\x82\x90\x9a\x15Z\x855\x9f2)\x943F\xb5\xc3\\\x12C\xcdx(\x9f\xecvv\xb4~\xe3M\x99IE\xdbe\xe6\x1atj\x9e[\xe4x\xa1\x11\x13\xf5\x16h\xd0@\xeb%\xf9i\x1f;\x13\xd4\xd6IG@\xee\x01\\\xedB|\x03y/\"Mb\xbd\xe8\xf3N\x08\x0fk\xe7\x96u.\xc6\xae\xa0[\x9aG\x1e\xbb*V\xe3\x07\x88]\xd5\x87\x7fP\xf8*b\xfe\xad\x9a\xbe\x99\xc2\x10\xd6\xc8\xc8\x0f\x86\xb0\x8a$\x81V\x16CX\x18\xc2\xc2\x10\x16\x86\xb00\x84\x85!\xac\xd6\x0f\x86\xb0\x1a\x1f\x0caa\x08\x0bCX\x18\xc2\xc2\x10\x16\x86\xb00\x84\x85!,\x0ca\x1d\"\x84\xd5\x86\xc7\x16X\xd8\x91\xc2C\xad\xb5?nD\xc3\x8b\x0d\x84\x86/Z\x02\x17\x0e\xd4\xbe\xfc\xf1\x8d\xa7%\xed\x85\x11\xb5\xfeI\xd8\xc0i\x15O8@\xf1HP\xb3d~\xa8EU3\xc0\xea\x02\x1d\xe5\xe8\xdaa\xe1W\x8e\xe4#\xc9i,@\xf3\x8c\x90Dx}z\x07\xc1-T\xd0\xa7\xfd\xa0\xde`\x13\xf6\xf7 \x9b\xa8\xdb\xb0T?\x9dR\xfb\xc1\x045\xaam%\x9c\x1bb\x8f\xe7R\xcb2{\xbb\xc7\\\x19\xe5u\xc2(P\x16s5\x0b\n\x0b\n\xe9U\xa6PnZ\xc4\xe2\x15a\x8c\xa6\xe6\x11\x89o\xa8\x146\x17shZE\xd7\xe3U\xddw,\x8cMRou\x83\xb7\xd8\xe0\xbf\xf5\xd6\xbc.K\xd9\xbcn5*\xd9\x85w7\xca\xf2u\xcdv7\xd2|\xbc~}}1\xfd\xf4\xee\xf2\xdd\xe5\xf5\xe5\xeb\x9f/\xff\xeb\xe2\xed\xf4\xd3\xbb\x8fW\x17o.\x7f\xba\xbcx\xdb\x93}\xf1\xb2z5$\xdd\xf5\x87\xbf\xbf\xbf\xbax\x17\x92T\xa7\xebL\xf6K\xef\x10s\xf1\x9f\xc1\xaa\x8dnk}\xc0\x15\xcd6$\x93}w\xdet\x9c\xd5e_4\x93\xd3\xf0\xa0\x0f\xe8\x01\xbdF\x18\x82\x0d1\x84\xdb:\x18\xd5\x01\xa1E\x15\xb5H\x855\x81\xdc\xe1\xe2\x83z\xb2'RE,\xc0@B\xbf\xb9\xa9\x06\xf5\xef\xbd\xe6\x95\x11?F\x03\x11\xb37y\x1fB\x03\x9b\x8c.\x92/\x01U/O\xb8Z\xaf\x13\xa9\x83=E\x10\\eQZ\xb2z\x0d\x86\xf4\x14\xdc\x9daT\x97\xd6\xa9o\xe8v\x1aXE\x18\xdd\xc2\xfa\x8d\xeeS,\xdb>\xed0k\xc8\xd3\xeeg]O\xf6\x82t/]o\x9d\x97\xbe\xb2 \x0c\xb9\xa3\xe4\xdc\x8f\xa6S\x96 B\xf9(b\xde\xe2\xc6\xac+wf\xb3\xa4\x89\xd0\xf12\xcb \xab\xb9\xfc\xba\xe3\x19\xa7\xbf\x91W+\x0f\x03oU\xab\xa4\xc3[\xd5*Z\xc0[\xd5\x1e\xd1\xadj-\xc3\xfb\x90\x04\xab\x10~\x95\xe9\xfd\xb3\x94\xc77\x8e\xcd\xdb\x94\xb3\xf6K\x93JUkEw\x18\xc0(*Uy\x12\x80\xcf\xa1r(\xf8\x04YTA\xfd\x07YTE\x92{\xc4\x83$\xb2\xa8\x90E\x85,*dQ!\x8bJ\"\x8b\nYT\xc8\xa2B\x16\x15\xb2\xa8\x90E\x85,*dQ\x01\xb2\xa8\x90E5\xd8&O\x88E\x85\xd7\xa7\x0d\xf8\xc3x}\xda7\xd0\xf4n\x87&\xe0\xf5i\xf7\xa5^\xbc>\xedwr}Z/\xaf\xf4\xeck\x85\xd7\x11~LF\x19\xd4.h\xa6\xac\xc60\xad\xd3\xb3\xba\x99\xa5~\xa2'B,\x1d\x0c\x96{zj\xbb\xf9\xcc\x85\x11;\x8f\xedq\xf9\x0dG\x15\x86\xa4\xd6iBHM\xa1\xa8\xd3A\xc9\x9b]\x88P\x00q3 h\xa3\x93\x0d\x936\x07#J\xe6\xd3\x0d\xe9=P\xbaf\x97r\x87\xa8\x9a\x07%j\x06w\xabA\x92\xe6 \x8f\xb1+\xebP\x82f0=3\x80\x9c\xd9I\xcd\xdc\x9b\x98\xd9\xd5\xaa\x81\xa4\xcccR2C\xec\x15\x04\xda,\x08\xb5[0\xa2\x93A\x8b\x02\xee\x97\x88\xd9\xc7\xfa\x1eC\xc2#\xc9\xac\xe5\xef\xf7.\x9d\xe2\xfb\xb7\xe2\x84\xb8\x9bU\xeaA\xe1@\x82\x88\xb9\xaa\xc0\xdc\xb3]\xb9K\xc5\x84\xd1L\xc8\xb8\x85\x02Q\x0d\x97yu\xef\xa4\x91x%\xf9\xe9\x1f5\xa3\xa4\xe8j\xf3iG3T\x92\x97\x01\xb0\x01\xed\x82e\x0ft \xde\xc3\xb8\xdb\x90\xe4:MHt6t]\xd6\xa8\x9b7\n[_\xe9\x0c\x83\x0f\xeb\x11:uy\x7f\x91m\x19\x82W\x86\xab\x0fZ;7b\x96\x88Y\"f\x89\x98%b\x96G\xc3,\xfby-\xc3\xb8\xe5H\x13\x1f\x8c]\xde;z\xd9\xc3\x16\xe9\x9c,\x11\xc3D\x0c\x131L\xc40\x11\xc3D\x0c\xd34:b\x98\x88a\xee\xd1&\x07\xc30\xf7`\xb3z\x07\x86z\xd8\x98wb\xa8\x8f\xdd4\xce\x0cm\xdc\x85\xd0u\\(rM\xa1[\x9a\xdf3\xd7\xb4v\x11m\x1b~\x1aD8-.\xa3m\xc5z\xf1B\xda\x91lJ\xa4\x85\x16I\x90\x16\x8a\x10+B\xac\x08\xb1\"\xc4\x8a\x10k\x00\xc4\x8a\xb4\xd0\xb6_;\xa6E\x84T\x11REH\x15!U\x84T\x11R5\x8d\x8e\x90*B\xaa{\xb4\xc9\xc1 \xd5GK\x0b\xfd\xbd\xf1A9\x13\x94\x89\\\xecL u\x19\xb4\xb0B\xdd\xa3\x83\x12C+\xe5=\x19nhw;T\x92\xf9G\x8e\x0d\xe9\xf6~h\xa1r\x18s\x0b]\x96!\xde\x86x\x1b\xe2m\x88\xb7!\xdevox[\x17\xb04\x84\xb5\x05\x9b\xf4@\x9c\xed^Q\xb6\x9d\x83\xfd\x88\xaf!\xbe\x06\x88\xaf!\xbef\xbe#\xbe\x86\xf8\x1a\xe2k\x88\xaf\x8dh\x93\x03\xe1k\xad\x94\xa3\x81\xfd\x99!.[c\x9f\xe4\xe5\xdbvd\xa1\x8a>\x84 \x88|E\xe4+v\xf3\x15+\xb0\xde\xae\x94\xc5*\x16\x89\xac\xc5\x91d?d-\x16I\x90\xb5\x08\x88\xa2\"\x8a\x8a(*\xa2\xa8\x88\xa2\x0e\xa1\xa8\xc8Zl\xfd\x1dY\x8b\x88\xaa\"\xaa\x8a\xa8*\xa2\xaa\x88\xaa\"\xaa\x8a\xa8\xeaCGU\x91\xb5\xe8=\x95\xdd\xac\xc5\xd3\xe1jX\xc8\xb2U\x96}nbmu\x91\xfb\xaf\xd2-\xbe\x1f\x8cc9\x95\x19abA\xb3\x82a9\xa7\x8c\xaf\xd5\xcfq\x05\xea\xe9\xa5P\xbeU\xef\\\xebW\xca{W\xf5E\xc5\x8c\xaf\xdd-\xb9&\xcb>f\xa4\x97\xcd\x93!Cv\xa8\xb3\x92F>(\x0c\xaf'P`S\x84/\xf2j\x8d\xa1q0w\xa0\x844\xb4\xceDO\xd4jQrfI\x9e\x9e\x05\x10\xdez:#qboy\xb7\xf8\x9f\x9d\xe0\x179[&\xb3\x94FL\xf2\x1b\xda}\x93_\xf7\xc2vF\x04\x9d\xea\x96:R\xc5U\x01\xd5\xd1`e\xcfhJ\xb6\xaa\x86\xb6\x0e0P\x85\xd6\xdf\x03\x17\xa7\xe5\xf0\xaa\xfa2M\xe1\x94\xbe/\xdf|\xfc\xe1\x0f5\xb9D\xe1T\xda\x16\xb0\x8d\xa24\x11\x1e\xdd#C\xd6\xa5I\x80BBj+\x0b\x1f.\xf8\x02Z\x92`\xaa\xac\xf2B\x88\x91B\x0d\"U\x83\x85\x02\xd1\x16 \xf1)\xbdey\xd1\xc1\xbb\xe3\xe0\xc7M\x9eg\x94t\xaf\xa0\xd7I\x91j\xa0\x1fa\xfd\xf7\x89lT\xdf\xfe\xf7\x96\xf0\xed\xef\xc3MU\x8d\xa5\xca`\xa7jk\x96\xdaJ\xac&+\xbd\xd1\xd7b\xb1\nT\x91\xb57j\x8d]\"\x11j=t=`\x83\xb5Q\x02\xa4<\xdfbd\x1b\xb7A+T\xf0zL\xc6,\x9bV\x1cd\xc8\x1a\xbb\xe0y\x8cX#\x05\xd0\x1e\x18\x9b\xd4\xd6\x06\x1b\xc7i\xadQi\x1d\xac\xebE\xa5\xb5n\x12\x95\xd6?\x96\xd2*\xe4\x0e\x8f\xdc)\x9a\xc0\xb3\x94\xc1\x96~R\xf1\x9a\xcf\x9b\xb8\x84!<\xf1\x18\xce\xcf\xfa\xef#\x8aj\xb8\xa9\xc1\x8e\xc4Kl\xdd\xf2!6\xa7Rm\\z\x93\xbc\xa8\xc6\x81]\xbe>d\xd4%\xa2]\xfc\xf0\xfaZ\xb5\x96\xdd\x7f5\x92Zoo[O{\xe2\nnm\xdb\x87\xd1\xdd\xda\xfenj\x1d\x06\x100\xdf\x94\xb1\x0d\xa7l\xbd\xa2LhGA\x17\xf0\x99\xd5\x10\xada_! \x15i\xf4\xa9\x80\xfc\x17\xe3\x1b\xd7)\x97\x7f\x0b\x08L\x8a\x9c\xf3\x17R\xbaC\xc9\x06*\xe8\xe3\xb0)\xf2\x9d\x0c)\xc6\xe7\x03\xc5\xb5\x82&4\xbd\xa3\x8fd3:\xb3\x19\xb5\x1f\x18D\xe3\xdb\x0d\xc3\xaf\x01\xd4D\xfaS$'J~C\x05\xa6(\xf9\xd5M\xa2\xe4\xf7eK~\xc3e\x9e'\xaa\x83\xa7Z\x8aP\xbd_O\x93\x9c\xefr\xbe \x87r\xbbP\x82\xd0\xe2\xb2'\x08Y\xc0\xc2\x06\x08Ow\xe4\xd3jGw\xf9\xaa\xce;\xebI-\x8eCq\x18^[[\xf1i\xc5\xd3\xdb\x95\xb4\\\x1f\xa7\xf7\x7f\xd0U\x92\xf3r\xb5\xa7\xc5\n!b\xf6a\xc4\n\xeeh\x91n\x1e\xe4Ht\xfd\xdd\x9f\xff\xfc\xa7\xff\xef\xf8\x03q\x9a\xec\xbf\xfb\xf3\xff\xfb\xf1O3\x0d\xf5\xa43d\x97\xb5\\:\x85\xba\x8a\xd1 8\xacE\xbb'Z\x87F@E\xc0\x7f\x95\xa0\x81\xbab\xa4S\xc0\x96\xc8\xae\xba;\xd2Y\x89j\xd5ZJ\xf5\x9b\x12N\x93\xbc\x90lS\xc6\xf9\xae\xd7\x05\xe5\xbc-\xab\xbaH\xad\x8b\xc0\xba\xc8\xaa\x8f\xd2\xc5$\xd5\x98\xa4\x1a\x93Tc\x92jLR=z\x92jG`\xb5\x8a\xa9^\x92\xed |M\xfes\x14\x1f\xedEOZ\x8a\x8d\x0eX\x9b\xa5\xb8\xe8c)*:%\x88\xd1@.C\"\x19\xb5\xd7\xbcA\xc9}\x1a\xad^\x9d\x91>{PK\xb5\xea\xa0p\x93\x9b\x94\xb2\x99p\xc9F\xa8\x9d\xa4\xb5\x0b\xb1V\x12\xed\xeee\x02\x14t\x0e$\x04\x02\xd4+#N\xff\xd8!\xe9c\xcf\xceS\xda\xc0\xc1\xf2\xf1\xb1=\x8f\xd8\xcd\xfa\xc13/\xd5\xc2]\x18\xca\xc3\xba\xc1$\n\xe0{\xbe\xea\x05\x01\xb20@\x88<\x0c= \x02\xcc\x93:\xb1l\x0c\x01\x92\x8dWN\x86\x90\x9d\xf2\xedQ\x0b\x81]\x12\xc9X\xd9\x19\x82\xe9A'\xb4]\x1f\xa9O\x13\xea\xba\xac\x9f\xbe\xc51\x9b\xb9\x84R\x84\xab\xc3~\x9f=\xbc\xdb\xccA\x13\x8c\xc4\xb3\x97\xb0*\x05KE\xe68\x0e\x1f\xb9Au\xfa\xdd\xe3\x08a\x07\xd5;#\xf8\xc1\xb5\x10~\xe4\xfbs\x00\x80\xe9\xabSn\xc7\xdf\x9f\xf6\x19\xa2\xfeFZ\x01\\\xed\x9aK\x19\xdc\nV\xa7\xeaEWn4\xa9\x87\xd4\x88\xb7dZ\xe9w8\xff\xf4r\x18\xb9\x9e.\x15Z\x8c\x9c\x81\xc8\xda'\xda'6l\xea\x88\xe7D\xb9\xe1D\xe7\x11\x181\xbd`\xafC\x81\x13\x06U\x93\x1a\x08\xef\xb7\xb4\xa0J\x00\xd4\n\x10-Y\x07\\\xd1S\x8d\x0cE_\x17:{\xdb(\xa7\x06\xd0q\xae\xa0{\x8aAR?\x90\xa2\xde+#\xd6\xa9\x97\xf1\xack\x84\xb3\"B\x85\x02B4\x9f\x02\xfa\xa3\xa5B\xb3*m}\xd3w\x88_\x88\x8a\xe1:\x8a74\xf9ZNC-%\xfc@`M\x93tG\xb2\xe0syC\x93#\x9e\xcb:\x15K\xbe9 Gi\xce'\xa3\xb78g\xf5W^\xbc\xa7\xf7\xa4\x98\xa4Ua\xc8\xa9\xe8j\xa5\xca\x96\x8d\xa3\xbd\xed\xfa\x89\xfa\xc9\x16\xdd)\xb6z\x8d\x16\x0b\xf5\xee\x97\x0e\xc0\xdd5\x06\xa0\xa8\x05\x9a\x9bx)e\xfd\xad\x8f\x16\xc3z\xc5JU\xfbox\xf5\xb7\xd8\x06 h\x03\xf0iz\xf0P\x92\xefv\x07\x96\x96\x0f\xab\x92|\n&^\x1ar\xe0\xad\x18\xa2\xf7\x9c\xd3b\xe5F\x15g?9;\xf09:\x12\xf0\xb5.\xc8=R\x83\xc7\x107\x83J\xeb\x06T\xe9\xa5\xca \xa5\x9f\xa73\x84\xc6x\xf0\xea\"Iuv\x97y\x9e\xcd!\x84\xef\xf3\xdc*\xb8F2\xa7\xde\xfdJ\xc8\\\xeb$\xbb\x91.y\x9e\xd5\x0b\xaa)\x04\x88\x9f\xbf\xe1\xfd`\x1a\x1fN\xd8\x815\xc4f\xdbz\xd1\xeb\xbe\xb0cKC\xad%\x91\x9e\xc5\xc3-\xc9T\x8c>\x8bHS\x81B\xc7\x19+\x7f#IR\x1cd\xcfDc\xf8\x83\x91\xc8\n\xc3!\x88\xd4{y\x16dB\x97\xca\xd7\x86Q>\x95B5s(\x16\xaa\x85M\xbd\x90\x9f>\xfe\x19\xc5\x1e\xf5\xcc\xbe\x05\xaa\x81\xabR\xbe{;T\x1bo\x94\x8b\x93\xd8\xa8\x06n2!?\xbd\x85\xcb\x8f\x8b\xfc\xa8\x16A\xbd\x1b~5\x8e\xf8\x95\x90%\xb5\xc2.p\xb5\xbe{ \xf21U\x19\xc3\x14|\xd4\xb3\x8a\xdcuQ\xd0\xbc\xb0\xb8>\x9c\x16\xd8\xd3P\x90\xc8\x93O\x04\xfcN\xa8\x92\x96\xf2\x962v\xd8\xe9\x81\xe1\n\xbc&0b\x13\xff\x1b\xc6\x8d\xf5\x1e\xa6\xb3\xe4\xbc\xf8\xa5b^\xb3\xf0\xe3\x9a\x15\xce\xc8\x92\x8d\xfc\xd2\xc1+\x9dg\xdcL\xb0u\xd0\xda\xcf\x1a\xc1\x10'SQ)v+\x8ed\xec\xd1\x9b\xf6y\xc0\xb9\xeb\xaf\xcfq\xe8\xff\xa5\xac\x1e\xaf\xa4\xbc2\xc7\xc9\xb7\x0c)\xd3\xcc\xaa\xae\xf3\xeb\x0e\xd3:\xc5\xe6\xe0\xaa\xa7e.\x03\x1a\xa7\x9d\x9de\xbb\x06\x1d`\xa7\x8f \xa7x\xec\x88\xeb\xaez\x7f\xf2\"\xe0.+#\xf8\xf8X\x97o\x05X\x1c\x87\xf7\x19`}\x1c\xdci\x88%\xb2\xd5\xe9,\x91\xc9\x03Qb\xfe*\xd9^p\xaf)\xdf\xeb|\xb7K9G\x8dt:\xec'uo\x1e\xf8o\x1a\xb6\xaf\x98\xc6\x9fSU\xde\xa7\xe6\x1f\xa0\xae\xee[\xcf\x88\x0b\xc6i\xb6z\xfd\xaa\x92\x18I\xe8\x14\xe6\xb6)\x82\xc0\x18) X\x04\xb8\xcd\xef\xb4\xbab\xfb\x9c\xa7\x93\xdc\xad2\xf7\x87d\xab\xf4\x08\x9e\xd6\xb5\x9c\x9f\xf7zzK\xd7\xf6\xd2d\xee\xa2s\xa7\xf1\x08~y!\x14\xc3\xe2'>[\xa5\xc3\xee\xca\xbcH\xa7\xd0\xa0YZ5uP\x00\xa8\x12\xe8\x99\x90N\xf0w-\xab\x12\x7f-\xd3;\x99\xe3/P!\x18\xef\xa6\x97!\xdb\xa5l\xb5\xee!1D`\xfe\xda\x80\xb9u~]\xfe\x95\xb2tw\xd8U\xc0\n2x\xa7\x82F\x01\xa3\x94\x95\xb4\x80\xbb\x1c\x93\xb7eX\x8c\xc5B\xb2#\x9f*\x80\x1a\x11?\xd3\x9d\x18\xf9\x84\x13\x93\x1d\xe1\xbc^\x89-\xd8\xe6\xd9\x9a\x16\x88=\xd5\x9c\xc5>7\x08\x04\x17B\xe4%\x99\x947_\xc2w\xb0\xcbY\xb9\x1d\x94{\xd1\xc2\xb1~\xd2\xae\xac(\xa7\x86\xe7b\xfc\xdb\xfc\x8e\x16\x0c/\x7f\xaa&b c\xd2Q\xf9R5\x9d\x82\xc5G\xe5\xa1\xa8\xdf\xd8y]T\xa5\xa3*\x1dU\xe9\xa8JGU:\xaa\xd2_\x82*\xed\x927b\xccJ\x8cY\x81\x18\xb3\x12cV\xe4\xdf1f%\xc6\xac\xc4\x98\x95\x18\xb32\xe0L&\xc6\xac\xe8z\xb7\xbc\xddo\x88>O\xd9a\xf7\xf4%\xfc\xb5-\xba]\xbe\x7fw\xf9\xee\xea\xd5\xcf\xab\xab\xebW\xd7\x1f\xaeV\x1f\xde^]\x9e\xbf\xbe\xf8\xf1\xe2\xfcM\xd7D\xd7m\xfa\xe6\xfc\xf2\xdd\xd5\xc5\xf5\xea\xf2\xfc\xfd\xc5;o\xeb_\xde]_\xbc\xfd\xf7\xc0\xc6\x97\xaf\xae\xae\xfc\x13x\x7f\xfe\x1f\xe7\xaf\xaf\xfd\xed~|u\xf1\xf3\xf9\x1b]\xea\xfb\xb5#\xe7!9\x16\x1b\x17\xba\x1d]\xd9\xb0\xb2\xd3\\\xc9K\x17)^\xc0GJ\xbd:\x80\xba\x90\x91\xa2\x0c\xa5Y\xa3\x10\xa0^\x80c\xe4\x97\xae\x87\x9d\xc2|\x92\xb1`\xe7{N25\xe8\xc28D\xfb\x00\xfb\xa3\xb4\x9fk\xd6\xcc\xda\xf8\xa7\xee\x98\\\x1f\x8a\xea\xfe\xc4\xca\xe2\xa6\xcc\x80\xc6q[\xa0\xd0\x1f\xb6\xf58l\xd4\xb6\xed\xd18\xa8\x04\xa9\xfeh\xf2w\xc70\xad\xd3\x92\xd4JP5\x19\xccd\x1e\xab\x02\xcc\xfeh\xd5\x93\xe1\xe3\xddP\xca\xa0\xa0\x7f\xc3\xfb\xf2\xcc\xc3J8\xef\x0f*\x7f\x1f>\xe4\x86\x08\xdd\xddb\xca\xdd\xa4\x8cd\xab\x92d\xd9\xc3J\xda\x04\xe6\xb2\x01>\xd8S\xdcl\xc6\xf9\xaeBJn\xb8`\xe7S\xbba\xf9\xf4\x1eVB\x04Y\xdd\xd1rx_\xa1\x8a\xe9\xb58\x84\xf7\xf2\x06\xc7\xe6\x901\x0b\x97\x14k\xc03Rf{\x83\x15\xdar\xbe\xfcp\xb3K\xcbU\x99\xeez\xc1V..\xd3h\xf4kR\xd2\x17\xf8\xba\xb1\xff\xca\x0d@\xd9\xfax\x83`\xb4]ta\xd5\x9f\xaf\xd8\x85e<\x7f\xc9\x17V\xbc$\xc5\x11AY\x8d2?$?\xe9\x8ce\x93::\x053\x0b\xaa\xf6{'\xe4\xe7B\xd1w;\xea\x07\xf8\x9f\xae\xba\xe2\xa6mU}13P\xa6\n\x17/\x83EK\xbfX\x19\"Rz\xc4\xc9_\xb5\xc3\x19$FF\x112\x8a\x90\x7f,\x11\xd2AgT\x1dp<\xf89\xe2\xc4-,\xbf\x83r\xebNdN\xd9\x8a\x12WOg\n\x12\xb7{\xe1\xc1\xc3$\x00\xbc\x85\x02\xfb\x9c\xdc\x1c\xd9\x06\xc3\x86\xea\xdf\x8e\xd3\x13\xb4m\xa2\x88C\xba\xc2\xc7\xb1$k\xfd\x8ba\x81_\xb2$\x06}9\xf3\x89\xe9o\xaftc\xa2 !\xb1\xaaU\xbc\xdd\x90PU}\xacY\xaa\x94V\xa1?\x9fW\xe9p\x13\x1d?-\xf0\x12\x1e\x93z\xe2\">\x03\x87\x0c\xbb\x9e+D\x1f\x8a\xd7s\xf9z7\xfcj&\x82_:q\xea\xafu\x90Z|\x9cp\xde\xeeDt\xfd2\xe6\x95>\x8dy\xa5\x8f6\xaf\xb4\xcb5\x07\xb0h\x7f\x8d\xd8\x1e\x8f\x9e\xefR\x1ee\xb5 \xba\x9b\xa7\xd5\xb6\x1f\xed+\xaf\xe8)\xa8,\x0bZ\xe6J\x99\x9c \xbb\xaa\xc1m\x85\xc6\xbd`\xd8Y\xcc\xcf\x94\xdd\x96\xdb\xca\x83n\x0b\xdb\x06;Xh\xa4\xa9\x0e\xe6\x0e\xd9\xc5v\xe3\x80m\x9cW\x03\xb3g3\xb4\xba\x8d\nK\xeb\xf3\x07QX|H35\x0b\xc20\x88?\x1b\x02F`\xf71\xb3\" \x88&H\x9f`\x10E\xd0\x9b\x06\xd0\x03l>\x135\xf8\xfb!/\x0e&\x8c\xf3n\xb8Ob\xb1@\xce\x9e\x16 e\xa5\x10?\x04\xe9E6\xcfK\xf2\x91jUS\xef\xf2\x92*\xd0\x92|_I8I\xcex\xba\xa6\x02\x8c\xd1\x10\xec\x01\xacr[P.\x0e\xfc\x94\xcb\x13pT\x94*6\xeb/\x94\xe3bd\x1e\x8c\x8e&BX[\xc0\x1beeV\xb0\xf6/\x8b?\xfbB\x8ci\x99\xaf>\xc7\xba\xa4\x10\x95o\xe0\x17\xaa\x0e\x08q\x08\xaf\x07U_1\x9c\xa7\xb7\xd0\x1b\nb\xd2t\xdd[\xed\x9f\xbe\xfd\xd70\xa4R\x7f\xb9\xe5\xaf\xa3]\x15\xd7\x97\xbd\xd4\xea\xe6\x90\xbe\xaa\x9d\xea\x12\x88\xb1\xe8|R\xf3\xaa9\xe9 <\xf3\x07\xcf\x1a\xea\xf7\xad\x85|\xfd\x0b\x01\x03\x94\xc4D\xa8\x98\x08\x15\x13\xa1b\"TL\x84\x9a=\x11\n,\xea\x90\xbd\xa0o \xf7\x16\xf55\x08,\xc7H\x8e\x02\x93\xb5\xd4':\xc5D\xa9\x98(\x051Q*&J\xc9\xbfc\xa2TL\x94\x8a\x89R1Qj\xc0\x99LL\x94\x02\x83\xcenL\x98\x82\x00y\xcc\x9c8\x85OB\xc2<\x1d\xcd\x9d T\xc67\\IT\xc6\x17\x8c\x89T\xc6\x96\x96d*c\xdb~B\x15t\x93\xaa\x00\x86G\xc4j\xef\xc5\xc8\xd8\x18\x19\xfb\x07\x8a\x8c\xad>]\xa2\xe5M\xb2\x829l\x8e\xe6\x84+0\xd0\xc6 \xe5\xd7\x9e|\x05c\xbb4&b\xc1\xf8\xde\x9cIY\x10\xd4\xefP\xa5x\xb6$-\xc3h\x8ed-\x08\xe1p\xce,\x140\x8c\xe7I\xde\x82\xa3\x0c\xeaJ\xe6\x02\x88\x1e\xfc?\xb8\x07\xdf ;\xbeD08\n\xc4\xba\x13\xc3`\x9e1\xb5o\xad\xf1\x8f\x94,\x06\xe1\x8e\xc9\x8e\xbb0\xc85YMr\xb4sr\x96\xd8\xb0j\xcd\x7f\xc4\xf0m\xbbs\xd3\xb7\x1a\xf0\xae\xa8\xee\xc3\xe1\xe2\x0cY\x16\x18`.\xba9\xa3\x9b3\xba9\xa3\x9b3\xba9\x8f\xe2\xe6\xb4\xc9\xa7.Wg0)\x0fpw\x9e\xd0\xe19Rd\x8en\xcf\xe8\xf6\x84\xe8\xf6\x8cnO\xf9wt{F\xb7gt{F\xb7\xe7\x803\x99\xc1\xedi\xd2\xe8\xad\xae\xcf\x10\xf9\xcc\xee\xfe\x1c\xec\x00\x1d\xe3\x02\x1d\xe1\x04\x1d\xe2\x06\x1d\xe6\x08\x0dv\x85\x1a\x9c\xa1\xe3\xdd\xa1\xd1!\x1a\x1d\xa2\x7fT\x87\xa8\x89\x9c\x059Eg\xb2U\xda]\xa3a\xae\x17\xb3K\xc7\xe9 \x9d\xd0\xb1\xd5M:\xa9O\xaf\xb34\xac\xf71*\xf5\xacNS#kt:N\x83\xf8\xa3\xd7Ccv\x0e{\x1d\xa8\xc7\x1b\xdc\xe7H\xf5\xbaRc\xd9\x94\xfa\xf3\x87.\x9b\xd2\x83\xac\x107\xeb\xf1\xe0\xda\xefn\x9dm\xec\xd6\xf7~t\xc4\xb1\x1c\xaf\xb1BL\xac\x10\xf3\xe5U\x88\xe9\xb9\xe6\x87D\x02\x8c\xc8S\xd6\xa4\x869\x82\x01P\xca\xf0\xe0\x95\x94D\xccu$\xe7\xacZ\x10k\xa3\xab\xbe&\x80\xa3\x01\x7f\xfd\xf4y\xa0\xa5\xe2\x97F\x80\x14\x83\xc8~\x99\xc5*\xb1d\xaf\x00_\xc0\xe2d\xbc\xec\x1a\xf6/\xde\x9cU\xde\x12Z\x9c\xd5\x11 \xb6\xc9\xb6\xa6f\x92l\xb9U\xb4m]\xdc\xdft\x13\xad\"\xd1*\xf2\x88\xad\"-\xc9$T\x00\x1af\x0dA\x95\xf5\xb2[\x88q\xb0\xe8c,\x95\xe8:D\x17p\x9e\xb8<\xa2N\x0fl\xe5\x03g_J1[)D}\xfa\xce\x12\x88s\xaf\xe1\xe8e\x0f\xbdH\xa2\x01o\x87*\xe3O\x88\x1b\xa2I\xcan\xd5\x84r\xa3,\xc2\x03\xf1\xe4}\xd7\x95<\x18O\xfa\xc69\xab\x0dK?W\xb3A.\xe8\xd5\x9e\x11.\xf0-\xab\xe1\xcd\xfe~\xd0qMu\xd5:\xce\xe8\x97\xb6\xfdk\xf0\xe1\xd8\x95\xa7@\xd4\xe9*L-\xd44(I\x81\xdd\xb6\x15#\xbdS\xa32\xe4\xec\xd5|\xc5o\x98J\xe0Qz\x02\xd4\x1d\xb7\xa2\x13\xa4\xe2X\xef\xe5\x0dYCTh\xben\x85\xc6K\x82>\x8f\xfa\xe2\xa1Y\xef\xbaXl\xc3`\xc3\xcd\x89~\xa8w`\xad\x07c\xed\xd8\xea\xc5T\xe3\x95\x87\xbe\xb9F\xec\xfcz\xb1\xd3\x8d\x02)\xbb\x9d\xae\x83\xb8.\xc1p\xf2\xc4\x0e\xd8\x85]~\x11Bj\xeae\xd9\xa4S\xd5\xf9 \xa9t\x97\xb2\xb2\xb9|u\xf2\xae\x89\xeeV\xa6(*\xe7\x965\xca\xb5\xca6K\xf2\x14C\xe4EwfY%e\x9b\x0c-%+\x81\xc7+\x99Z9j\xcc\x9d\xba\xbf\x800v \x99J\xd2\x84\x94A=\x84P<,\"S3\x8d\x1d\xf94i\xf8\x81\xa3y\xc5w\xcbhJ\xdb\n\x19\xed6'\xd9\xea&gk:\x08\xfe\xeb\xb1\xc4\xfb\xe20\x95\xa2\x0d\xb2+ e\xbe\xe3\xe6\x11o\xb2<\xf9\xc8\x05\xce\xad\x1e(\x19)\xdf\x1a,8\xcd\x9cd\xea7]\x83\x1cJ\xcc\x0dp\xa8pLT8(S<\xb4k#*\xdb\x89\x80Y\xd8\xe5\xebCF\x03P\x0e--\xaf\x10\xf4.\x8b\xfc.\xe5\x82\xfd\xcc\xe1>\x92\xe0\xbc\xda\xd7\x9d\x8e\xdbM\xaf\xfe\xde\x1b\xa7\xb2,\xa9\x04f\xdc\x0fL\x95\x91\xf8\xa55D5}\x08\x11tnV\x88E\xab\xfb\xae\xd7\xb8\xd5?\xab\x8b\ns\xe68\xa4\x1a\x0d\x8ft8\x0d\x9a[\x0e\xa5i0\xee0z\xbb\x11r\n\xf5K#\xb6\x7f\xbe\xeb\xb8\x82\xee\x8bq\xdf\x14\xa3\x98z\x85\xecg\xa6\x13\x1cj\xa2\xb7rP\xf0\xc0\x05@8'\x05\xe8\x1b\xcfC8*\x0c\x9a\xc3`\xce\n\xcei\xf59,\x8c\x9a\xce\xc8\xd1\x83\"\xd8\x1c\xa3{8/\x18F\xb7s`\x184v\x18'\x06\xc3\x0c\xdc\x1c\x19Bf1\xc0\xb7\xe2\xe7\xce\x00\xd3| G\xbb\xbbF\x12\x8a\xb6$\xfd\xba\x8bB\x83i\x14?\xdc\xf0=I\xbah\x18dt\xed\xbb\xf9\x82^3\x95\xd7\x18o\xa4\xd5\xf6A\xd78S\xb6N\xef\xd25\xca\x03\x159U\xf4A\xa6y\xab\xaa<\x97\xd5C\xd9\xc5\xa5\xd3x\xdb9\x82c\xb0\x8b\x10n\xd1b\x16\x95\xd7\xb8^\xe5L\\\xc2\x02\x18\xe0:,0\xe0w\x98/\xd8\xd9\x85\xad\x1e\x8b\xbb\x93'\xa6\xbf\xbd\xe0d\xc1\xe1\x19\xf0\x97g\x84oSv;\xa3.\xcc\xd3[F\xd7+EB\xefS\xb6\xce\xef\xc7\xc9y\x0eG\xc0.e+5\x90 \xd2SF\xb1;\x06\xd6\xf9=+\xd3\x1d]\xfd\x8d\xa4\xd9j\xad\xd2\xc5\x83\x89\x84\xd6\x13n\xf3j\x83\x85\xbcr\xb6Z\xe7\x87\x9b\x8c\xe2\x02\xe6\x9eso$\xb9\x84Y\x86\xf1\x81\xa9\x82\xb9\xba\x86@Op\xac\xeb2\xdd\xc8\x80\x87\n\xfa\x9czc\x0fD\x8fA\xe1\xacj\xe2`\n\xe5\x87~\xf0\x1c\x008\xb1\x00\x0c\xb4(\x04\x1b`\xd8\xa8\xfex\xee \xec\x00\x17\x86\x98z\x0d\xc6\x14S\xcf\x93\xd6\x13\x8690yX\xed[k\nG\xc2&0bn-{\xce%\x1e\x0e@\xdd\xab\xf4\x96\xa5\xec\xf6\x82m\xf29\xf0\xf7\x8ed\x08\x1f)\xbb]\xa5l\xd3\xf7\xb4WK\xed6\xac\xd6\xa9~\x03\xfc\x0d#\x9a\xaa\x8c\xa2;\xa1\xbea\xe1>y\xb3\xfcJ\xb6\x1bd+\xd0\xdf\x1b,\xdd\x99\xe8\xce\x14\xc1\xce,V\x8d\xb3\x87j\xc4\xc5!>\x05\xf6\xed\n\xdf\x99MX\xd2\xa7\xec\x10\x90f\x98\xf2pqH\x9f\x9bC\x04\n\x9c\x9bY\xec\x99*\xf0\xe8s\xb4\n9N\xf1\xc6#\xd8\x1c[\xa4\xd1\x17\x10\"\xc6\x04\xee\xb6\x0b\x12\xe6\x12Z\xbc\xee\x87\x93\x88(]zU\xe2\x1d\x175\xb9z\x9d\xef\xc4z-\x91\xe8\xa1D*\xa9{\xc1\xa0\x94\xd9\x9c\x13\x18z\xe1g\xe8\xad\xc7=\x93\n\xf9\xb4\x9a\xab\x1f\xe9\xfa\x1e\xd7\x9d\xf6\xcd\xc9\xba\x9b\x13yO\x9a\xe4f\xc9\xb5\xf0^\x19\xb4\xf1Vm@\x85\xc7#\x7f\xaf\x0d\xecIAI\x89l[\x03#K\xf6\xe0a/H\x8f\xa90^ .\x19\x8a\xe1yA\xbfYd\xbd>mM\x9dh\xcd*\xc0\xbf\xbb\x92`\xd0~\xdf\x81\xc9\xc1\xf0m8p\xeba\xb7(\x96\x19\xf6\x82\xdf\xb5\xc3\x9b\xbd\x8b\xf0\xad?\x0e|yN\xe5\x0d\xcd\xe8mW\xab\x19| k\xd9K^\xac\x8e$\x1f\xd5\xab:\xd6\x00|K\x8a\x01i\xa1\xbeSm\xb6\xb5\xeb\x80\xbb\xc9\x99\xba\xdd\x07K\x89r\xd8\xd2\x0c+z\x12\x06$A\xf6\xb6\x80\x8b\x12R\xbed\xf9=\x93\xd5>sF\xa1\xdecu[\x11\xdeK\x95')\x8a\xee\xb2C-S\"\xbf\x97zP\xce\xe8\x92\x8d\x86\x899L\xa1k\x13\x84\xb9zr\xf5\x06!\xd0\x06\x1e\x80\x00\x17P\x80\x81\xd7\xf8\xa0\x0f\xe6\x1e\xd0\x08\x8d\xe0\x82H\x18\xc2\xd3\x1e7tv\xa6\xff\xf4\x86d\x84\xd9\x83\xf9\x86COX\x90\xb0\xf3\x80\xacE\x89\xe79\xa0/\xa8\xe8\xf0\x00R\xa8+\xfd\xa2\xd7;\x92Q\x86\xb5!4\x80\xa4\x9f\x12\xba/e\xb9\xf9\xb4\xd4\xae\xe9\x02\x05\x07x\xc3\x8d~!\x88D\x96j]\x1cvyA\x81\x1f\xd2\x12\xcd>\xc8\x1f\xb3T\x0cT\x19\x19,9]}2\xa8\xafc4\xfd\x13\xaa\xc1G\xafbd\x84|y\x11f9* \xf5\x9e\xde\xf0t\x80\x9c\xa2\xf3B\x9a\x1c\x8a\xb4|X\xe1\xe6'>\xed\xde\xd8\xc7\x9a\x96$\xb5\xdf\xcb:\x82\xa1\xd6_M:\x19h\xcd\xc3N\xf7\xa7\x94\x0b\x85-!\xd9T\x93\xd0\x96\x92\xb5\xfd|\x87\x92'u1\xa2\x91\xb4T*\xf1\x0d\xe1i\xa2,!\xe8i\xec1\x1b\xc7\xe8\xe0\x99\x01>\xc7\xbe\x8d\x8f\xfc\x9c\x0e\xdb\xf4l\xb8\xbdF\xbf\xf7\xdf{J\xf6\xfb#\x0f\xda\xf9\xa57\x89>%f\x9c2~\xe0\x90\x90\xbd\xa4\x88\xd2\x1a[\xfd\\\x1c\xb2\xa6dLB9\x97\xf7\x1bU\x87#\xb9\xaa\xf8\x92lI\xca\xce\x04\xf5J\xb2\x83\xbc\x05)\xcb\xb4G\xb0&%\x01^\x16\x87D\x8eS\xa5\xb2\xcb\x11\xaa\xab\x11\x9b\xfb@\xbf\xe1K\xc6KRR(\x0b\xc2\xb8\xa4\x87;\x92lS\xd6\xbd-\xb1\xcb\xbep\xc0\xb0\xd2\xb0\xce~\xe6\x8b\x0er\x0e3=\x8e.\xf0\"p\xbc\xbd\x0b\x8f\xc4\xb69\x15\n\xee\x0bzwT\x0c\xdc\x12\xbe\x9d\x07\x17L\x0e|3\xfa\xedIQ\xae8-WF\x92V7\xf3,\x0d\x02\x96'\xfb\xb18\x88\x9a\x06j\xa0\x94\x95\xf4\x96\x16\xc6\x91\xc0\x0bM\xd5\xc7\xb0b\xf0\xec4\x04\xee6\x84\xec8\x18\xe8\x0f\xd8\xe6\xd5@\xda%)JN\xcb\x9f\xe4\x91\xf4\xcf\xf1\x89\xeb\xbb\x11\xc0\xd1\x9cP\xae,\xeb\xf6\xad7\xdc\xf5(\x06\x90\x94K\"\x8a pn\xfc\x13-\xe6\x9a\x97s\xa0\xc6\xd9;\xd7p\xdem\xd8\x14\xf9\xae\"\xe1\x90\x1f\xca\xfd\xa1l~k\xc8\x89{\xde\xe8\xcd\x9d\x7f\xf2\xce1k^w\x92\xd1\xc8~\x7f\x92q\x10\x13\x94\xb7\xf3$\x03\xd2;!\xce't\xae\xc1\xec\x00\xd7\x08'\xc8\x9a\x9c\xb3\x92u.\xe8\xf1,\x1b\xda7\xa7\xca+\xe9[\xcb\xfcY\xcbB\xb2\xe4\xcf5ekZ`\x9d\x00IO$\x97\xb2U\xe1#\x99\xc31y\x9a\x18<\xf1\xccc6\xf2o\xaf\x97\xb3\xf4e\xd8\x06c\xf7\x87\x1bs\x80\x89G\xd03\xf5\xaa\x9c\xc1\xce\xbe\x06EdyG\x0c\xb9\x10\xd3.\x1b\xb4\xa5\x82\x7f\xfd\xce?\x9e\xb4y\xcd\xb3[\x8d\x91\xd2j\xcc\x1b\xd5\xab\xc9&\xa15\xf0\xcaf~\xc9\xccb\xb1\xd0\x1a\xb8g\x0dV\x99\xc6b\xcf\xd0Z\x8c\xed\xd9l\xed\xd0\x1a\x8c\xed\xd8c\x0b\xd1Z\x8e\x1d\xc1l)\xd1\x1a\x04t\xdc\xfb\xcd$\xddO\xb6\xa88\xba\x7fz`724i\xe6\x18\xe0\x01\x03\x1f\xfb.1\x03\x9958\xeb\xb5\xe7s\xe0\xa2\xc7\x95\xaf\xb5\xf4\x8e\x06A#b+\x8bG]k\xe1\x07J\xb0\xab\\\xee0\x00\xad\xd5\x1c\xa3\xb8\x83\x04\xb4\xc6\x81\x83\x19\x7f\xb7\xe9\x96'v\xf6\x06L\xca\x11`\xa05\xf2b\x0c\x04b\x0d\x8c%O\xb3\x84$8F\x94I\xaf4\xdb\xac\xac\x0eJ\xd5\xd0\xc3\xa3[\xdf{\n\xad%\xc4\xc8Dq\xcf\xa0\xccoe\xd0V\xed0\x93a\xad\xca\x93\xa3L\x80\xbf4\x81HK$~\x95\x07D\x19\x0c\xd3\x02\xe8'U5\xa6@\xf3`\x8e\xf5l\xf8b\xc9\xae\xaa\x1c\xcf*\xce3e\xe8R\x12@%kG\x88\x11Z\xaf\x9f\x01\xc9\xb2\xfc^\xbc\x841\xa8I\xb9d \xc9\x92\x83\xaa\xc7\x92o`s@)\xfd\xc0\x9a\xad\xe4\xb8\x86\xfcPBZ\n!\x18+\xec\xdd\xa1\x80\xaf\xe4\"1\x9d\xff\xdaR&\xe7\x06\xa4\xa8\x9d\x882(\xb9\xdc\xa6\xbc\xb59U\xc9I\xdc\xbf\x94\x0bDX\xa7\xb5{\x91,\xb5\xd1\xe1~\x9bs\xaa\x85\x03\xeb\xdb\x94r\xb8!\x02\x9br\xb9\xdafwq&u?t\x0dXnC\xfa\xbeJ\xad\x0cTk\x7f\x16\xf0\x8b\xee\xd5L\x08\x83\x1b\xdal\x11]\x03\xa9\xc2\x93U\x01\x195\x8f\xdd!+\xd3}\x96\xca\xfe\xdb}\xeaP6\xa0\xd0C\xdb\xa9\xd18\xcf\xa4\xa6\x84\x00\xa2m!\x93\xf8+\xf6KG\"T\xae\x94\x97\x17D\x7ft\xbddx\xb7u\x81\xbb\xa4<)*M\xf8\x1b\x8e\xf7E\xd33\xe5\x80\xdb\xd3B\x96i\x15\x1b\xf6\x1b\xfbM\x06\x8d\x17\x14+\xe8\xb4\xe7\xb7d\xcfD\x83\x14c\xaf\xeb,\xe4n\xef\xbfm\xeb\x97V\x94\x95EJ\xf9o\x0d\xfe?\x0f\xf3\xf6L/K\xe1\x943\xac4B\xd7H\x053\xd2\x92\x0c,=\x98\xf4\x19\xbbT\xd4\xed_m\xd0\xfc\x9d\xf7\x0fa\xfe1\xc4\x06\x07U\xc1\x0cG\x08[\xe5\xcfv\xed\xc16\xcc\x05BT\x9egS\xe0\x89\xe5\xa5\xaaQ\xb52\xaa\x9dA 5\xae\x03\xef\xa6\xe59\xe6T\xd4\"GY\x90\x047\xa8\xaa\x80\xc5\xd6\xc0\xf2\xf2\x85\xfa*\xc3\x13\xf8a\xbf\xcf\x1e*&\x85\x04W\x0fU\x08\xdbU\x8c\xf8?V\xfc\xd1\xaa\xe8wgZ\xbf\xe1\x8d6\x08i\x8c\xa6\xce \xd2~\x9c\xa9X\x91S.\xf1\x89\xfb>A?(\x88\n\x0c`d\x94)}\xae\x0f\x93\xbc\x17\x12T\x05\xc7\x9c\x80\xc3.\xe3\x95\xfaFx\x92\x1f\x7f\xd0\x95a\x19\x96\xe0+\x98\x07\x02\xed\xb7\xc6\xfb\xb7\xdfp\xa0\xce\x9b\xe2\xfd=\x0e=\xd0/(H\xab\xbb\xbe\x01\"\xa5\x85\"\xfb\xea\x87i\xd0\xee\xad!\xe6\xe0\x01y\xd1t4Kb\xbe\x89\xb6\xdb\x18\xe7i\x9c\x04\xa1\xea\xe7\x14+R(\xb1\x0f\xa3\xb6\x01\xf4\xd6f|\x08%\xfaG\x9f\x88\x93\xf8\x07P\x8b\x91V\x8d/\x83 \x98\x88\x9f\x9d\x11\xcc\x06\xa3vv\x10v \xc6\x83v2\x85\xb0~\xc7\x1c\xf4\x17\xc6\x1c\x06\xda\xb1\x1eoL\xafa\xfa\x83\xc4{\x92e\x1d\x11\x9f\x7f\xd3\x17\xf2\xad\xb1\xea\xf1*\xcb\xa7\xb1\xe6\xc0\xe9j\x0e<\xe9\xfe\x15$\xc6\x19\x85\xaa@\x81\xae\xf5\xeeD\xd1\xeeCeR\x9bY\xc6kLu\x8fK\xc4;} H\x98\xb8u\x84\x81\xcd6B\xf5\xd0\xbe\xf9\xaa\x81\xf9\x08:oO\x8d>\x95~\xb4\x9c\xb9\x1c\xd6\xaa\xa9w\x7fT\xbbIa\xa8I.\x18:\xce\xc8\xe9\x9b\x1b5\x1f\xa7\x7f\xce>'\xe5\x93\\\xb9\x84?\xd5\xd4/G\xd9\x87\x99\xab{\xc3\xaff\xa1\xb0C\x1c\x0d\x84\xe8\x9c\x95\xc5\x83^{\xbd&* \x01O\ns\x05\xcd\xe8\x1da\xa5\xa0\x82dMJbp\xc4\x0e\x8b\xd0\xf5OM\xfad\xa4\xa8\x82B O\xd9m\xa6)\x02\xdfpm\xb6\xe2_\xbed\xd2\xc1\xa3Z\xea> \xb16\x01\x18/\xf2B\xde\xcc\x9b\xa5\xbc\xb4\xf9\x9f\xa2\xa4\xa3\xde\x8f\x92\xce\xe3\x96t\xbah3J\xe4qv2Q\xf6\xa9\x9d\xf8s\x08<5>{P\xf1\xae\x17~\x801\x06m\xc7:\xdb\xe43a`@\xf8\xeb\x00h\xf5GX\x07\x84\xbd:\xf9H\xb7?k\xc0k\xdd\xcb\x80r\xb6\xce\x91\xac\x81\xae\xf5H\xb60Ww\x90k\x9fhX\x02\\\x07\xedK@h\xeb\xc0\xfe\\A\xad>\x81\xcf'\xecy\xc2Y\xbd\x92\x85\xc9\xd8\xe3 d\x1d\xd5\xa7;\x84uT\x97\x81\xc1\xab\xa3\xfav\x87\xad\xfa\xbb\xec\xfc\xd2W!f\x0bW\xed\x82[@\xa8\xea\x00\xb2\x14\x90\xbe\xe8\x0dQ\x1d0\\`\"\xa334u2F\x05\x06\xa5\xfa\xc6\x81\x80\xb1\xb0\x8d'v\xd3\x0bl\xe0\xd0=\x02\x02Q'\xf7\x1f\x16\x82\x1a6\x8c\xe1\xd7 \x1d\xe7\x94\xa1\xa7&z\xe1\x0f;\xf5a\x01\x04a\x02\x8c!.\xb3\x06\x9bvq1,\xd0\xd4\xcd1\x9f\x98\xfe\x0e\x13\x85\xed\"g\x98\xbd\xaf\x89Y\x9dI\xe2\x9d\xc5\xc6\xe7\x0f\xa4;\x8di/@\xc6\x0d\x81\xec\xc1\x06\xb6\x00Y\xd7KQ\xfa\xbd\xc6\x14\xaf!\xbb\x15 \x07\x8f\xea5\xa6x\x99z\x8e)^\x9d_\x0c\x07?\x9b\xccl\x02\xcc\x00\xb9y \xa9\x8b)^\x10.M\x87\x8c\x06A#b\xab\xd9\xf2\xa1\xcc\xb3\x08\x93\xacg\x1a%L\xbe\x0e\x1f\xcc\xf8\xbbM\xc0\xff\x8cr\xb6\x8d\xde\xf8e\xed\x10\x8c\x81@\xac\x81\xb1\xe4iV\xa9\xdb\x84\xbda\x92\xb7\x17.\x069lb\x8aWL\xf1\x1a\x9e\xe2\xd5RSlV{n7\xdb\xc7 \xa5\xeayt\xdda\x17_\xae\xeb\xcea0\xf09\xec\x0c\xaf\x8e3Z\xb4\xf3\x14\xe7\xb0WlS\xde\x15\x98\xbb\xab\x17MZx\xd6\xe4\xdcI\xe4&%\xfe,\xf9\xa0\x94\xc1gB8k\xbd7\x9f\xc8\xe9\x136\x1d\xe5,\xa1\x05\xaf\xde\x92\x96\x100\x1b\x08\x98\x11\xb6q\x95\xb7\x84\x00L\xac\xdb\xf50\xd2\xd8\xd0&:\xda\xcb]\xc2\x11&a\xf8\xd5\xa6\xaev\xc4\xb4\xaf\xa1\x04\xa6e\xb9\xaeR\x98`8\x84\xa0>\x9d\x11e!\xc7\xea\xd3\x91\xcd\xc3\x9e\xc6\xb6n\x18\xd8W6\x13Z\xa8\xee+\x9d sb\xfaI\x8b;Z\xd0<\xac\xac&\x04.\x1b\x02\x97\x8e\xed|%6A\x1f\xd4Wf\x13\x82 \xb3\xfaXUv\xff\xa9\xc0\x80\x93\x81\xd0\xd3\x01\xabf\xef2/\x84\x96\xe1\x04\x1b\x85\x0dG wYN\x08\xdc\x13\x9f\x00\x0c\xadU\xf9Kt\x82M\x97w\x94\xea\x84\x91s\x0d\x1a\xd8_\xfd\x12F\x0e\x1f\xb4U\xa3\xcax\x82e-\x81\xe5\xff7\x0c\x18\xc4\xf8\xbbM\xf3\x9a\xd1\x1fn\x1d&\xcc/\x0ecH\xb2U\xc3\xf2M\xe4\x94\x9e?\x0b{p\xfa\xcdan\xfc\x0f\xf6\xa1C\xf0\xc8\x10<:\xb6\xf4:\x9f!\x1c\xc8\xc1\xad>\x87\xfa\xd6a\xee\x11C\xfd\xec0p`\xeb3\x97\x0d\xe1\xb3\xfa\xdd\xc1I\xefB\xfc\xef\x10\x8c\x890\x00\x1ba*\x89\x9c\xd9'o\x1d9\xd87\x0fa\xb0\x14fg\x89\xbe\xfa\xe8\xab\x9f\xea\xab\x87\x1e\xb4M\xf1v\x9a=\x8d>Gg\xa7\xce\xeb(\x1f\xa7,\x8d9\x87os\xdf-\xaejZ\xadl\x04\xdb<[7UV4z\x82\xd8\x84\x95^d\x0dN\x1d{]\x0c\xdb\xe9\xd7\xf4JDN\xca\xd2\xb5 8\x0b\xb8\xb6z\x0b\xcb\xd6\xf3\xe5\x0d\xd9\x0b\xba\xc2\xfc\x83y\x0b\xbc\xc2\xfccZ\x0b\xbe\x82\xf7h&\xa0\\\x1b\xf0}\xa8\xa6*\xc8\x8eC\xb1<\xcffA\xb0v\xadY\xd3\xcaD\x93v\x90\x0e\x16q\x9d/\x99\xd7W\xaf\x16\xbcGf8\xfc\xf1\x9dM9\x7f\xedT\xbc\xa7/vq\xd4\xd9\xbf\xa7\xeby\xab\xda\x14\xf4\xf1\xd5.\xd4\xe7d\x94\xde\xfc\xaa\x96_\xc5\n,\x9f\x03\x06\x98\xb1\xc8\xbcc\x8d\x9eM9\x1d^$\x8fg2k^~\xee\xc9\xb8\xea\xfd\x80\x1b.\xb5F\xae\xba?\x10\x04M\xaa\x9d\x17\xa6T\xbb\xf0\x1a@\x10\xbc\x87\xaam\x80\x15G~\\:nxM \x18??\xafB\xe9\x9ecx\x8d 0\xccq\xd4\x90Rb\x17p?\xdbh\x96'.\x9bf\x8b\xb3\xe8\xe4\xbeS;\x08t*9\xb8z\x10Xf7J\xe1\xd5g\xd9\x94a\x14\xec.Ky)\xfde{R\x94\xa9\xd0\x95\x8aVE\xa1f\x11ZQ\xa1\"\xdf\xb5\xdf\xe0\xf9\xa1Ht\xc5\xb0\xcc\xbb]\xf2\xb2\n\x1e\x1e\x12\xca\xff\x05\x14\x14k1h1_\x97\xa3 dT\x08\x1c\x19\")\x8b\xa4\xac\xfe,\x80 L\x801\xc4e\xd6L\x92..\x86e\x8f\xb89\xe6\x13\xd3\xdf\xc1\x82\xee`\xe9v\x9aH\x1b\xefJl7\xf3\xc2\xb5\xc7\xac\xd6\x07\xdf0\xbb\xde\x11\x06\xfe\x02B\x9bB\x1d;!\xfb\xa3\xda\x058w\xec\x0c \xd4\xc13j>\xf1\xaeD\xfdsJ\xb7\xcf\xc4x\x96xW\xa2\x03\xdf\xa3\xd5n\xd2\xda\xbe\x12\xab\x9d\xc9E\x1a$c\x04\x8b9\xa6N&\xfaOg\x11t\xac\x89{'\x96o\x02\x0cx~\xc0\x1c!e\x04\x18\xf2\xbc\xac\xa3\xdfk\xbc0f\xc8n\x05\x18\xf9F\xf5\xea2\xf5\xf9\xc0\x15\xbc \x8b-|\x05v\x02\x84\x0e\xb3x\xe1-\xaa3\xbag_!\x9d\xd1\x1d\x07\x9a\x00'\x8c\xe0+\x98\x13\xd2q\xef7\x93\x05a6\x83\xa0 0\x03\x8c\x82\x03I]\xbc0\x06\xc2M\x85!\xa3A\xd0\x88\xd8\xca[\xf5%\x00(\xc1\xae\xd8\x84\x99\x0dg\x1a%\xccx\x18>\x98\xf1w\x9b\x06\xf7\x19\x8d\x886z\xe37$\x86`\x0c\x04b\x0d\x8c%O\xb3\x9a\x14M\xd8\x1bfV\xf4\xc2\xc5 \xad5\x16\xa1\x89Eh\x06\x17\xa1i\xc1\x945$\x81kqJ\xaa\xe2\x8aP\xa6E\xefM\x9bxIL\xb4Y!6\xd0\x18\x11bq=\xd2\x00\x8f\x82\xcd\x84\x90~?\xb9\xf5\x91\xfc>e\x08!\xf5\x83\xc6\xfd\xdc\xd6\xd6)\x9d\xb5\xbe{H\xdd\xb1B\xc0\x07P\xa4\xcf\x1a\xea=\x9c\xcaD\xab\xaa\x17\xe6\xed\x96\x1b\xad\x8b\xa1\xaf\x8e\x00\xa3\x89\x90\xec\x81\x8d\xda\x179\x05\x18uB\xd0\xa3\xab\x9a\x1eM\x90\x18M\xa4\xddI\xd2\xc3\x98\xf9\xc4cv\xec\xb0\x8b$\x1b\xb6KI\xc4\x8bZ|\x9b\xb2Y&A7pY]\xd9\xb3\x83\xd53u\xea\x83\xc7/[\x88\xad\x8eW\xb9\x89\x0e\xfb\xdb\x82\xaci\xed&\xba\xcc\xc8\xa4\xc8\x04F\x86 \xa0\x9d\xbd\xbd\xa2\xaa\"\xbf\xe8\xa7\xce\xa6\xab& \xd7\xdb\x94\xcbG\xf7\xa9\xd8)e\xd1Sv\n\xd5l\x0d\n^\xab\x0d\xe2\xf9\xa6\xbc'\x05Z\x84\xc4f=\x00a\x0fK\xc6\xf74II\x06\xcb\xa79{\xa1\xde]>ES\x1aak\x0e\xeb\x83\x98.\xf6\xb0I\x0b^\xc2\x0f\xf46e\xa8\x85\xaaT> \x9b\x92\xb6\xa6\x88\x17\x0d\xec\xd1\xba\xa1.\x9c\x00\x92\xf1\x1c\xa7\xb9de\x0ekZ\xa2'o+-^\xa4\x99\\5\xe9\x840\xd8\x12\xb6\xcehm\xbb\xab\xd7\x7f\xb1\x01\x96\xd7c\xc9V\xb5\xd9\xac\xda\x9a-\xe1pC)[2N\xcb\n\xde\xaaa\xce -\xeb\xcd#\x9c\x1fvt-#eZ;\x95r!\x18\xbc\xc87/\x84^ \xa6\xcbZ\xcb\xbcNw\x14\xf2\x02~B5f\xc90\x11\x92$[\xba\xaea\xb4\xee\x0bG\xa3\x9f\xd2\xd2\xa2F\xcd\xa1\xb3\xb8`\xeazK\xd1\xa1\xaeNK\x06\xf7\xe8\x8b\xd9\x1dx\x89\x89\xb5\xb4\x10}\xd3\xf5b\xc9~\xa6\xe4\x8e\x82\xd8\xc02\xc7 \xa2\x7f\xd0\"W)\xa6%\x9e'\x10!+\xbd\xa8RM\xe5N@\xcaxI\xc9\xda\xb2\xd4\xe9Z\x9fo\xa1r\x04 e\xe0:\xdf\xb1\xecA\"Q\xba\x91\xa7*\xc0(/\xc5\xd2-\x8b@\xf1`\xc0\x12jf\xf3\x8a=\xe8\xc4\n\x10\x017i\xd2 \x0f\xdb\xe4\xcaR/I\"Z+_ -\\2~H\xb6@8bE)-\xde*\xc8\xab\x95v~\xc8\xd6@\x0ee\xbe#e\x9a\x90L,Ou_\xe6\x03\xa8\xbc \x84\xd5\x0c)o\xdd\x1eGn\xf2C)\x8e?#L\x1c}\xd5\xbf\x80|\xc4\x94\xb4\x04\xbe\xc5\x89\xe4Ir\xb0\xe4\xc2u)/\xa6\x0c\xbf\x92\xb4C\x0c>G\x02\xc5q\xe1M\xc1\x9aJP\xaf$\xaf>\xfc\x89}\x82{\xd2P\xc6\x01\xc7`\xdb\x95jTW\xfa\xb5\xf6\x9a\xb7\x0e\x9c\xf14^K\xc3\xf7\\\xa7\xb1o\xf3V\xd3rq\xabR\xde2\xbbW\xe0%\x9e\xcdU\xc1\xa0\xcf\xa5\xc1\x03\x19\x10\xb9\xf5\x1f\x96[C\xdf\xaec\xe2\xda\x10\x02B>\xee\x0d\x8f\x8f\x83\x83a\xf9\xf3\xa5{\x86,\xfeH\\\x1d\x0c\x0b3pw\x08Y\xd6\xa3\xe4\xf2\x00V\xd3b\x10\xe310\x80\x10\xc6\xa3\xbdfg<\xe9M\xb2H\xb6B\x82\xc8\x16\xaf\xe5\xbfS\x98\x0b\xaa}=N_\x1bw\x14/\x91\xca\xa1\xa2\xb4jt\xa0lmf+&\x01\x81\xb2\xc3\xee\xe9K\xf8k\x1bj\xae\xae_]\x9f\xaf>\xbc\xbdx{q}\xf1\xea\xe7\x8b\xff}\xfef\xf5\xe1\xed\xd5\xe5\xf9\xeb\x8b\x1f/\xce\xdft\xc0E5\x17\x8d\xcdO\xae\xdf\xff\xe5\xdd\xe5\xf9[\xf3C\xfb\x93\xd7?\xbf\xbb:\x7f\xa3\x1f\xff\xaf\x1d\xf9eC\x0e\x19\xe2\xde\x90 \xf7\xd8\x1enbe\x8fJ7@\xea\xadL1\xb4 g\xf5\x1eo\xf2*\x8a\x00\xb7\x9e\xbf\\29\xcb3\x10C\x9f\x81Z\xea\x19\x88\xff\x0b\"\xdd\x9a\x13\xdei\x07/\xc03\xdd\x97\xf0F.\x0dpn\xda+\xe2\x85\x97\xf0\xaa\x9e\xa0`7\x7f\x13\x14\x83\x97\xa4\xc0\x90\x83-\x85|O\x99\x98\xa2`Q|K>\xd2\x85\xd6\x83\x9a`\xb7\x13\x92|d\xf9}F\xd7\xb7\xaa\x93\xfae\xe0%\xddWQ\x06X\xae\x87\x16{R\x94\x0f\x80(\xae\xf7m\xeaX\x05\x04w{]\xc0\xbb=eUK\x0c\x9cX\xb2\x82\x925\x96E\xe2\x94I^V\xd0\x84\xa6w\x14\xf6$\xf9HK\xae\x0f&\xf7\xbd;\x9c\xe0\xbd\x90d9W\xccP0t\x96C\x96\xb3[Z\xd42K5D^T#,Y5\x84YK\xc2\xe8m\x81=6\x94\xac\x84\n\x1d\x13\x05#WQ\xdfy\x01\x07\xa6\xbeL\xc5\xcew\xef\xdf\x9c\xbf_\xbd}\xf7\xf6\xdc\x85\x94\xb2\xd5\x87\xb7\xf8\xaf\xedq\xf50\x04\xc7\x02\x86\xed\xa2\xd6\x0b0\xbf\xf4\x12\xb9\xf7\x0b\xc9\xbd1\x80K\xedX\xb5\xcdx\xce\x9d\x15\xbc\xac\xa0@E\xa7\xc0\x9af\xe9\x1d\xee.\x86\xd9?\xc8\xb7\xcf\x14S\xdd\x91\x07X\xa7\x9b\x0d-\x1ao\x086\x00\xc1\x97j\xc6\xfb\x00\xf7\xb4\x10\x82\x05\xde8Y\x8f\xda\x1bSE\xf6\xa8\x01\xe9'\x92\x94\xd9C%\xe0\xc9~M}\xda<\"\x0d\x1a\xd9\x89|\x07\xd7\xdc\xc4}\xa8\xce\xb0\xcf\x8b\xb2\xef\xfb\x85\x10\xd9\xa0\xab\xe4\xe4Ei\xa7\x0fjW\xf2{\x95$\x8b5\xbc\x00\x91\xaf\xc5\xb6R\xa5SH\x06\xb8(\xe4\x83\xb2\xc1\x925C\xc3&\xa5\xd9\xda\xa5\x8a\xbc+,\x11x\x9dE\xf6\xf9\x94\x9fY8\xf8\x93\x997\xfd\xaa\xedK(O\x8a\xfc\xa8\xc7\x8f\xea\xad\xa9\x81\x12O\xd9*\xff\xaa\x81\xa5(\xdb:\x12\x13\xc4\\\xe2\xec^%\x1f1\x19\xb2\xdc\x89\x11'hA#\xf0\xb9s\xe2\xd5J:\xd8=\xabRj\x19\xf2\xc0RA\xe3\xbc\x83r\xfa\xf7\x03\xf5\x17\xb1h\x0d\xd9\x8b\x93tMH\x99C\xaaqlAP\xd3\xc2Z\x03&\x90\xd40!D\xf5\xed\x90x\x13\x03\\\xb5\"\x8fo)\xa3<\xe5\xd2\xeb\xc7hB9'\x05\xaa\x12\x05-\x8b\x94\xde\xc90 \xac\x08\xb3d\x95\xb2sKEG.\n(\xdd\x8d\xf2\xcbk\xac1\x85\x1a\xd9\x1ca'5\\\xacW\xb2z\xd5\xca\xa3\xf3c#\xa5\xf2\x13\xce\xf3$%u\xbe\xa9&H\xcd#\x1e\xaa)M\x15\xb7\xe4\x9cM\xec\x0eLB\x9e}\x1f\x8c\xfd\xca\x86\xfd\xe1\xedk\x06\xcf\xba\xeb\xf7W\x87\xc2\x9b\x15dY>\x18\xe0\xf7\x15|x\xff\xf3\xb7\x05U5!1\xc4\x04\xbd\xe7\x92H\x08\xca]\xed\x91\x04h\x04\xe4*\xf4\x86\x16)\xc9\xd2\x7f\xd0\xf5\x92\xed\x8b\xbc\xcc\x93<\x83\x9b\x03\xb2\x92\x9d\x80\xf4\xdb*\xaaG\xceH\xc6\x1e\xd4U\xd5\x94\xfdr\xc9rFa\xf9\xf4\xdb\xe5S\x01*\x05IJZ\x88\xf7(d\x84\x0b\xf2p\x8bh\xa5\x06\xfd\xf0\xfe\xe7o8\xecI\xb9\x95\xdd\x15t_P\x8eE\xd6\xd0\x10r\xc8\xb2\x07\xf8\xfb\x81d\x08\xc2rE\xeaU\x9c\xfb3\xc2\x91\xb1\xfd&\xba\xf8\xf66\xcfo3\xba\xc0\xd9\xdf\x1c6\x8b7\x87\x02\xc3\x10~{.g\x80\xaf\xab\xe0\xbc\x1bY\xffMp\xd5\x9c\xa5 \xc9\x04G\xde-\xd93\xba\xb8]\x9c\x89\xc5\xa0\xc9u\xf9t\xb1|Z\x05P\x90$\xa1\xfb\x92\xae\x9f\xa3\x85\xe5\x82\xc1^\xac/M\xe8\x19\x94\x94\xec8\x1c\xf8\x01\xc3\x11\xf6\x05M\xf2\xdd>\xcd\xc4 \x98\xd7M\xe1&e\x82X\xe0\x8d8\x0f{<\x00\x19\xca\xf3\xb0d\xf4\xd3\x9e&%\xa4e\x15\x9c\x92VZ\x03+\xe9'\xdc\xadW\xeca\x01?\xe5\xf7\xf4N0{!=|x\xffsU\xadN\xbcRn\xe9\x92\xf1dKw\x14~\xdb\x96\xe5\xfe\xb73\xf9/\xff\xedL\xf0U\x96\x83|z\x86\xa6&!M\xe4{)\xc0e\x0f\x18*s\xd8\x03\xc1\xb9-\x19\xa7\xc5\x1d\x9a\x19H ;\xb2W$\x0fG,\xf3\n\x1c$mD!\x90\x03\xe1\xcal\xc5_\x8a\xcd\xf9\xbfU\x00\x94\x9aP\xcaa_\xe4\x98X^\xcf\n\x05p\x19\xd6\xb4\x10/\xbcb\xf0\xd3\xf5\xf5%\xfc\xfb\xf9u\xa55}x\xff\xb3\x84\x8b\x07!D\x02\x81\xbfv\x8f\xf8\xfaaO\x7f\xfd\xeb\xafK\x06\xd5\x150\xac\xdai\xc9:p\xed\xfb\"_\x1f\x12A\x9d\x81\x16E^\xc8\xf1\x9a8\x15)\xe8`\xce\xbf\xb4\xdb$$\x11\x10\x9b\xe7\x1f\x0f\xfb\xban\x80\x9eA/\x06\xfc\xf0\xfeg\xec}K\xeep\xfbw\xda\xb9\xaf\xe5\xc1\x93j2\xe2\xef\xbb<]\xcbx6P]#X\x16t\x93\x17\xf4\xacj): ez\x93fi\xf9\x00\x8c\xd2uU\xc0\x02Q\xa3\xb8\x13\x08\nb\x1a &\xcf\xe3S\x84\xa8\x05<\xfb\xc0\xeb\xe84\xb1\x10\xe4Sd'\xdb\xec\x08#\xb78\xf1\x9b\x82b}\xa8\xaa\x87\xc5sqdo\xf3\x92\xbe\x94\xc1i\x9b\x03K$h\x889(\xe8W\xe6\xe0\xecA\xbf\x9fGI\x82x\xbd\x10\xc9\x14\xe5\xb89l\xb0R\x15\xe1\xf4\x0c9bZV\x9d\xd4E8\x1a\x80\xba\xa1\xb7)CS\xa2`2K&\x9e,\xe49\x93}\xca\x17I\xbeC|\xbbBP\xe2J\xb7/\xb7\x84u\xe1\x1c\x9e\xa9H\x1c\xba\xdb\x97\x0f\n\xf6\x9e\xc3\x0e\xe3\xa7n\xe8\x92\xe1\xe8\xc8\xca\xd2\xdd>C\xbe\xdc\x89S\xe2tGX\x99&\xbcc)\x80>#A\n\x8c@7\x85\x84;\x04\x9c\xbaM\x87\xcc\xff\xa7\n\xfaRu44\xca\x0d]\xc2]e\x89\xdc\xe4w\xb4\x0eh\x96\x80aZ`\xe7\x97\xde\x82\xbb3\xf9\xed\x15{\xf8M\xbb\xed\x8b\x01)n\xd2\xb2\x10p\xec\x98UE?\x94\x99@\x95\xb2\x10\xc8\x8e\x04G\x0er\xe3\xe4Q5K\x12\x90qY\x01]\x96\xde\xe0\xd8\x8a\xd6p\xe0\x87=\xca\xe4e\x8e*\xcd\xb7\x074\xc0\nb*\xc9\x05\xaf X\x12\xff|\x03\x87R\"^\x85\x02\\`\xb8\xa6\xeb\n\x19\xb0@\x91H\x06v\xd5\x998\xa2O\xdcW1\xa3\xf3OD\x00\x18\xfc\xe9%\x08\xa1\x12\x91@\x8dM\xea\xe5\xa7\x0c^\xff\xf3?Kk=\x00\xfc\x98\xe7\xb0\xc9s\xf8\x1e\x16\x8b\xc5\xbf\xc9\xdf0\x9e\x8e=\xa8o\x84=\xa0\xee\xf3c\x91\xef\x9em\xf2\xfc\xb9\xfa}\xb1X\xc8?\xd2\x0d<\x13\x8d>\xe0P\xd7\xf9\xb3\x7f\x12\xad\x9e\xc3\x7f\xcb\xc7Z\xcb\xdf\xf5Y~\xe7\x99\xe5\x7f\x90;\x122M\xf8\x1e\xd9\x94\xe8\xc09\xbd\x94?\xfb1\xcf\x17IF8\xd7g'\xbb\x15-\xe4,\xb4V\xff\xa6M\x1b\xaay\xff\xabg\xde\x97\x0f\xe56g\xf5\xcce\xf7?\xe6\xf9\xb3\xc5B\x90<\xb5\xa5r\xd6\xcf\x9e\xb7\xf7\x18\x17\xd0\x9f\xbfx|!\xa7\xff\xe6\xfc\xea\xf5\xfb\x8b\xcb\xebw\xef\x9f\xbf\xacV\xd0l\xbe\xf6\xbe\xeaA\x9b\xf8\xff\xe3\x99\xf8\xbf\xe7\xd5\x9cq\xd2/\xbf\x87\x7f\xda\xdf,~\xcc\xf3\xff^,\x16\xbf\xab'\x84=\x9c v&\x1e\xef%\x03\xf8OR\xf0-\xc9\xc4r\xb4\xe1\xeb\xf9w;\xabzJ7\x9d~>\xb0]\xd3\x13\x8e\x83\xc7\x89\xad\xfe\xaf\xef\x81\xa5YshZ\xf7x:\xd7[\xe9H\xa9\xf1\xa3b\xfcp\xf3\x00\xfb.\xa6\xca\xf8ft\x89\xa2+\xea\xc0\xe9\x92}c`\x01\xdf\nY\x10s7\x17\x82\xa3}\x83\x15f*\xf2 HG\x15\xcc,\xf7s\xc9j\xf4T\xe1\xb0`\x12(k\x0e\xa9\xc5\x87\xa3\x9c\xfa\xcd\xb7\xdf,\x99\xa2\x0d\xd5\x10gU\x0c\x00\x9e\xe1\xf2\xe9&\xcf\x177\xa4\xc0\xd9}\xfa\xf6a\xf1\x8f\xe5S\xb9\x1e)\xadHI\n;_>\xc5\xa7\x08\x04K\xf6\x1fW\xef\xde.\xd9\xf7\xdf\x7f\xff\xbd\xdc-\xf1\xbd\x91|\xeb\nC\x82\xbf!}\x95\x82\xcd\x81\xd3*\xf8\xf4\xf6\x90\x91b\xc9\xfa\xaf\x88\xc7k\xdaP\xc93\xa0\xbb\x1b\xba^7\xf4\xf2L\x91[\xb6d\x1aQC\x1b\x1d\xfc\xf6?\xc5\x94\x7fS2e\xabX}\xb5\x05\x8b\n\x84_V\x00*6[@m#\x98m\xd2\x8c*t\xad@\xfa\x92\x16} \xcb\xa7&\xb8iOl!\xa7\xb2|z\xd6t\x80\xd3xKv\xd8\xc9\xff/G\xff\x1f\xdas1\x91\xeecm:\x17\x1b%s\xb4wZ\xeeY\xca\xe1\x9ef\xd9\x8b\x8f,\xbfg\x08\xa3\xe8\x07\x85\xe4\xc0\xcb|\x07\x12\x14\xda\x07y&\xb9`\xe7t\xabD\x80z\x18q|\x98Z\x8a\x87\xb7d\xbf!\x98T\xa7\xb7\xcd\xb3u\x95IR\x8f\xd4\xadx-\x1e\xabC_2\xec\xa6>_x&`\xbdZJO\xec\xae4\xab_\xff\xfa\xeb\xf3\x97S\xce\xa4\xdd]\xebXp=\xb2\x8f?-\xbe\xfb\xd3w|\xf9T\xed\xba\xc3u\xe22\x10i\xa6\xed\xc6\xc8\xa2\x9b\xb7u\xdbG\xd7\xc6\xdd32\xc8}\xb7\x98\xb9\xf6E\x9eo\xe6\xb2s\xd5\x06\x89\x1d->fB\x0f\xc8\xf3\x8d@w\xfa)\xe5%\x1a\xf5\xec\x93X \xcdx\xc8L\xcc\xa3a/\x8eQ\xa6$\x9b\x99\x8c\x8bM\xd9\nSN\x19N\xe9\x9e\xf0\xda\xee\xb6\x0e\n\xc2\xf1\xd8\xd9\xaa\xe8\xfe\xf7\xa6\xe8\xfe%\x93\xe1\xfd\x96>\xacw|Z\xed|U\xc6\xf8l\xa6\xbe\xa6p\x86\xc7\xc4W\xe7\xaa\x9f\xc8\xcaW\xda-]>\x15)Z\xb8\xa2\x85+Z\xb8\xa2\x85+Z\xb8\x8en\xe1\xea\xbaIl\x96-/\xc9\xf6X\xb4Nb\xcd\n\x96 \xa3\x05+Z\xb0 Z\xb0\xa2\x05K\xfe\x1d-X\xd1\x82\x15-X\xd1\x825\xe0L&Z\xb0Z\x81a\x96p\x980{\x8d\xb2P]\xbc1k\xf4m\xad?\x9a\xad\xa2\xd9j\x8c\xd9j\x16C\x952.Y\x0dT*\xb4\xd1\x04\xc6\x05\xfd\xfb\x81r\xdd\x0e\xcb\xe71R\x05\x84\x83\x0dI\x87\x83\x10M\xc9\x98x\x83O\x86d\x9a\xb5^1\xa4\xc7iO\xcd)rZ\x03\xf7\xd3~\xaa\x1ctSy\x00\xc6\xa7\xcc\xa9wc\xda\\L\x9b\xf3\xa7\xcd\x81\xc1daI\x9f\x83\x16\x1a\x8fM\xa1\x83i\x18\xedMU\xe8\xb4\xb4\xa5\xd4iM\x0ciu\xe0\xc3\xc7\xc0i\xc4\x94\x06{\x8a\x1d\x18 \xcf\x91j\x07m&\x12\x92n\x07\x1eF\x06\x1ef&\x9f[S\xef \x00\x92\xc1\x00\x04GI\xc1\x83\xfen\x02\xf8R\xf1 t\x05SR\xf2\x00\x0c\x11q\x1e(p\xa5\xe8\x81>\xe9~\x9a\x1e>6\xa7\xea\x81a\xb9\xdd\x89\xf5\xe1\xe7\xe4i{\x86yX\xd2\xf7 \xe0\xfc\x8e\x92\xc6\x07Cl\xc3_a)\x10\x88\n\xdf\xe3U\xf8\x8cE\x08\xdbjWP\x01B\x05\xb6Z\xf1\xc1%\xfb\x81rt'\x88f\xaf\x1bZ\x885FU!F\x8e%1s\xb4\xdb)\x81P\xae \xb9n\xbd*\xf4\x80u\x97\x15\x98\xdc\xc4gT\x1fg\xcc\x806\xb2X7\x83\xb5\xea\x8b\x934F?Ut\xc9\x98\xa3\xf4F\x9f\xe6\x18\xa0;\xfa\xb4G\x8f\xfeh\x90X\xa7\xe9\x90Q\x8b\x8cZ\xe4\x00-\xd2$<94\xc9\xb9t\xc9\xc9\xb8\x1e\xa8\xcaim]:\xa5O\xab\xf4bi\xf0t\xa2n\xe9\xd6-M\xf0\xe8\xd1/Gi\x98>\x06\x08^&([8\xf5\xcc\x10(\x07\x03P\x1cM\xd74j\x9b!\xfaf\xf0J\xa6\xea\x9c}\xad3$3\xcb\xaf{z\xb5O\xa7\xfe\xe9\xd5@\xcdj\xfc\xe7\xd1BM\x1bd\xd7DCN\xf6h\xda\xa8i\xaa.\x94\x1a2Uk\xb1\x19\xf91\x00\x91\x1b \x86\x8c]\xb3C\xfb\xf0\xad\xef]\xc3\xc1I\xcb\xd2\x18\xa6\xd0\x9d@\x05\xbfX\xdca\xddH5\x0d\xc1I\x99M\xc9&\xb7)3_\xaa^\x9fT\xdd\xa4V\xed:z\xe6H\xb7\x16\xde\xd8\xf8\x91\x9a\x8d\x92\x13\x03\xf9\xea\xd9W\x83T\xda\xa9\xf8S\x05t\x12\xae\x84\xb1KrK\xdfK\xe7\xddB>_\xb2\xbf\x0b\xd5\x10\xdf\x10=\xc0\x9e\xdcR\xd8\xe5\xbc\x04\x8a\xd1\x96\x18\x8a\xe96/y\xaf\xc9\xf6\xaf\xcd\xa0\xd5Cku\xf2\x1e\xf3\xb4\xba\xd0\xbc\xb9`\xbd\x8a\x9a\xd5\x82E7\xadu\"\xb5_\xe1kK&\xf4eN\xcb3\xbc\x8eBE\xf2r\xbc?^\xde@\x81<\xec>\xe5c\xadUr`\xcdL\x90\xb7\x82-R\x06\xb7\xef/_7\x96\x03\x15\x19\xc1\xe1~+\xe4\x10\xc9\x9d\n\xf9x\x8d\xd2U\xe5k\xadb(\x84\xf0\x8d\xb2\xb5\xbeFTw\xaa\x16W\xf9\xae\x99C\x13_\x05P\xd0=EG\xee\x0f\xa4\xa8\xf7M\x8f\x98\x01\x80\xd6\x02\x10\x16T\xd4\x8c%Zb\x8a)\xc7e\xc9\x91P\xa9\xdfh4\xd2h\xc3GXmx\xd8\x9d\x11r\x98\x9a\x95F\xf3J4\xafD\xf3J4\xafD\xf3J\xab\x9fI\xb8\x1el\xcf\x88\xe6\x95h^\x89\xe6\x95\xfa\x13\xcd+\xd1\xbc\xd2\xf9\xf8O6\x9aW\x06\x8e\xfd\xb5\x9aW\x1aq\xa6\x13\xfcK4\xd0\x8ev\x96hg\x89v\x96?\x96\x9d\xa5~\xcdc\xfa\x18\x90\x0d\xd1\xeb#<\x1b\xe2-\xfdT^\xa9J\xc7\xef\xa5\xfe3\x87\xed\x05\x11\xbc\xaa\xa0\xbcR\x8a\xd5\xb8\x9dw\x06+!\x19\xa8\xc6\xa9UD\x89q\x16\xda\x1a\x03\xc5|\xe3\x04\xee\xfd\x0c\x81bm\\h\xe0\xb0km\x94d\xc5\x8a\x00\x0e \x0e\xc7\x84\xbafve\xfc\xd8QV\xce\x81\x0b\xa4\xdd\xe5\xb8\x93p\xc0\x9e\x8a\xd9t%\x19I!&\"\xc4\x17\x86\x10N\x90l\x15tW)\x93\x92\x13\xd5\x1c[\xe0\n\xa9\xccYjRx5|7PR\xca\x18X\xdb\xa7\x1b2\x99\x17\xbe\x90\xc9 \xbcj\n\xd1\xcf\x81R\x89\xe9\xba\x04\x08?\xc6\x88M\x7fXl\xea\x03b(\")#Ce\xee\x9b\x84H\xcdJ\x84\xd4<\x0e\x91\xe6q\x925\xdd\xd9\xce\xf04~\xb2\x89\xb6\x8c\xc1\xf7\x98\xc8\xcf1L\x1b#\xee7\x91\x9f\xfed,w\x9d\xa8\xa7\xfe\xa9x\x95V\x83A\xd5z\xfb\x89\xfc\xf4'i\xb8 E=\x192AK\xd1\xf0\xc1w\xa3\xc8\xcf \x9b\xd1)nK\xe9N+\x9a{\xa2\xb9'\x9a{\xea\xc9\xfeQ\xcc=V\x1e\x1e\xac\xeb\xf6z\x08\xd7p?\xb0\x82f\xe4\x81\xaee\x1f\xb3\xc8\x0f\x15\x9f\x98Qz0\xa2d\x1f!\xadp\xdfs%\x1d\xaauC\x87\xb9Yd\xf8\xc7\x088\xb6\xb3\x0b\x81\x9b\xce\xbbCa\xe7\xaa\x13\xc1d\xdb \xc3\xb5\x86\xe1\x119\xe6\xe0\"kH\x919\x90\xc8\x18>d\xbc\x081tb1@(\x06\x08y\x03\x84ZH\x83\xfa\xe3\xc2X\xa1}\n\x9d\x9d\xa5\xa2\x96\xf7\xba\xd6\xa1\x17\xeb\xcd#\x83\x96\xb1\xacv,\xab\x1d\xcbj\xc7\xb2\xda\xb1\xacv,\xab\xdd#\xe9\xb1\xacv,\xab\x1d\xcbj\xc7\xb2\xdae,\xab\x1d\xcbj\xe3\xe3XV;\x96\xd5\xfe\xe3\x94\xd5V\x7f\xfdn3I\x1d\xf128\x83aC\x06\x1c\xce{\xb5\xff`\xb3C`A\xe5h\x9d\x88\xd6\x89h\x9d\x88\xd6\x89h\x9d\x88\xd6\x89\xfa\x81\x8fdG\xebD\xb4ND\xebD\xb4ND\xebD\xb4ND\xebD\xb4ND\xebD\xe8\xa5_1\xf5\xc1;\xce\xe9R\x1f\x8c\xd5\xbc\xecWn9\x0bz\xb5o\xd9\xaa(\xfb\x02\xf4R\xec\xbay&\xb8\x16\xbbV9\xc5\xb4\xbep+\xd4,\xa1\x8c\xba\x19j\xc6p\xc61\xc9\x10\xb6h\x1f\xf5\xd8\xa3\xc3\x04F\xfe\xc8\x8f!\x03\xc2n\x8eS-\xfc\xb1@UC\xd7\x1e\x80w\x1f\xea>,\xf67\xad\x85s;\xc0\x80\x11\xd1\x16\x17mq\xd1\x16\x17mq\xd1\x167\xbb-N~z\x8c\x05\xa9\xb0\xcd.\xa7\x1e\x87\x91ro\xd6\x18\x18\x08\xfeQ,u\xf2c\xa8\xc3e`u\xd1v\x17mw\xd1v\x17mw\xd1v\x17mw\xf2\xd0\xa3\xed.\xda\xee&\x9c\xc9D\xdb\x9d\xfc\x0c\xca\x94?b\xac\x91a|\xcf\xcd\x15\xba\xfd\x07\xe2\xed\x151\xcd>\xa6\xd9\xab\x16\xc7O\xb3\x7f\xd2\xd9 \x9f\xbdy\xd8\x0d\x12:b\xeb\x16g\x8f=X\xf4\xc7\xf8\x81\xcf\x17\x98X\xf5\xe8\x8bM\xac\xda9\xc2\x13\xfb\xd4OZ\xb4\xe06\xbd\xa3\xac\xca\x07\x9f\x85\xd8\x941b1ZI\xa3\x954ZI\xa3\x95\xf4\x11[Ic\xc4b\xb4zF\xabg\xb4zF\xabg\xb4zB\xb4zF\xabg\xb4z\x06\x9d\xc9D\xabg\x8cX|\xa4\x11\x8b\xedzwfcN\x90\xf5\xa8\xf5\xa6\xbb\xc2\x9d\xd5z4O@a\xdb|\xf4\x99c\nKW\x1c\x9dO\xc9\x88\x96\xa1h\x19\x8a\x96\xa1h\x19\x8a\x96\xa1\x13X\x86LA\xd9\xf6\xb8\xb9\x00\xd2\xed\x8d\x97;\x89\x8dh\xa0\xaf9Z\x8a\xa2\xa5\x08\xa2\xa5(Z\x8a\xe4\xdf\xd1R\x14-E\xd1R\x14-E\x03\xced\xa2\xa5\xa8\xeb\xc9\xb2\x85{\xf4\xaf\xf8\x15k\xf7\xd5\xda\x8e\xd1h1\x1a-F\xa3\x1d)\x1a\xcdeK\x1c\x16\x8a\xd6~\xd5mM\xac\xef\xd5X\xfc'\x1ae/\x0b\xbaI?M\xb1 ~\xa4\x0f\xab}\xb7\x17\xf0\x80r\x17EC\xf6I\x9f\xb0\xd8\x97\xca\xaaL\xca-\xc8 H\x84U\x88\xbc\x90\xc2\x85 \x84eqH\xc4\x19\n\xf4\xdd\x14\xf9\x0e\x9b\\\xea\x17\xe0\x89'\x15\x87!\xfb=e\xebg\xe2\xf9\xe2\x7f\xd1\x07\xf1\xefY\xefG\x1c\xef\x0c\xc7Y,\x9e?7\xedt}\x81zs\xf7\xf19[O\xd9\xeaQ\x17,t\xb0M\xc5\xf8\xf5\xd9A\xca\xfd\x97\xbe+S\xca\x8cVb5c+\xad\xa8O\xff\xe2\x87\xd7\x95%\xa7\x12\xd0\x08\xc3\x0b0\x84\xc2\xaah\xf5\x9a\x96\xb4\xd8\xa5\x8c\x02eI.\x88\x01W\xe6.\xd4\xbf\xb9\xc0\x9c%\xab/\xe9\x10\x8f\xe4-\x19\xaa\x17!Ptv\xc2\xbc\x11\xc6X\xcb\xeeNK\xfb\x90\x8a\xb7\xac\x82\xbf\xeb\x8e\x81\xb2\xf5\xc2\xcc+M\xc7\xd8\xbb\xb8\x06\x7f\x0d\xbd#\xa6\xd5\xbcs\x81\x8d\xf6\xa4\x7f\x89\x8d\xf6\x10\x9fh\x0f~\xed\x80Y\xf0\xc55\xc6\x1d\xd5ob\xf1ml\xef\xd2\x16?8\xcf\"\x93\xb8J\x1ex\x19wg\x11\x1d\xcf\x83BK\xeb\xb54\xbd\x15\x12\x19\x94\xbbdF\xa4\x05\x83\xc8\xd14<\xce\nZ\x90=d%K&\xe3\x8b\x83Wbd7\x00m\xf9\xb7\xbe&\xb1\xf6>\"\xe3\xa8\xf1\xb0;/\x83 \xe5\xae\x0c\xe1\xab\x0ba\xe7\x8cu\x0b\xcf\x8ec\x1b\x1b\xa7\xac>\xdd\xc4\xde\x8e\x01\xf3\x89\xe9ool|\x8bei\xc93H\xcb6\x87\x0c\xe4\x9e\x88S&\xeaX\xd5\xe9IBL\x18J\x85K\xc6\xe9\x9e\x14H\xff\x18]\xc0\xdbw\xd7\xe7/\xc5\xfe\x17T\xfa1\xd08qC\xe1;\xa8\xa4\xc9\xd6\xc8(\x0cR^\x92\x9b,\xe5\xdb%#:\x94\xdd\xd0\xf2\x9eR\x06\xe5}.\xa7`\xbc\xebHg\xc3F\n\xf3Y\xb8\xf0q\xb1\xbfMW\xedX?e\xc6\xc7\xc1\xf6v8\x80Q\xa8\x9c \xc3G3\x01'V\xfb0\xda\x89\xcd\xa3qU[h\xeb\x9e\xe8\x80\xd3\xe8 $.\x0c\xd2R\xeb\x1a\xf9h\x02&M\x02Hm\xe2\xc6\xfb\x8a[H0\x03\xcaF\xc19\n\xceQp\x1eG3\xa3\xe0|zV\nQp\xfe\x0c\x82\xb3\x89E\xea\xc9\xe7\xcd\x8f\xbd\xd4\xf3\xfa\xd1\x92\x85\xdcu\xd1\x9c\xb9\x96\xc8\xda\x0c:Wt`\x05\xf9{RnO\xc8\xbe:\xdb\xca\xb34AV\x80\xe1bm\xa4\xc1\x99\x99$\x1b\x199i\x13.cXm\xf0\x8a'\x84\xd5\xd6\xe1\"A&^7$;\x8d\xe1\xd5E\xd2\xbd\xb7=\xf6\xf0\x0e\x16\xd5\xdfg\xbe?\xa6\xc6\xe8\xf5j\x9e\xabd\x94,\xf6\x08\xf8sh\x1d\xcf\x1e[u\xd7\xf0\x0c\xac\xe09\x99\xd9\x94\xee\xda\x9d\xbe\xe5\x83\x81Z\xc5\xb8\xe3\x18w\x1c\xe3\x8ec\xdcq\x8c;>B\xdcq\x8f\x91 \x05v\xd5\xec\x0c\"\xe1\xde\xf8\xe3\x93E \x1b4\x13\x9fF\x19\xe3\x90c\x1c2\xc48\xe4\x18\x87,\xff\x8eq\xc81\x0e9\xc6!\xc78\xe4\x01g29\x0ey@\xc0\xe7\x91+tF3\xdf\xe9\xcd|\xe3\xb2\xe7\xed\xa6\xb60S\x9f\xa9\x87\xb1\xe6\xbe\xc7]\x98qNc_\x19K/FCW4tECW4t=bCW\xd7[\x12K/FCV4dY\xa6\x17\x0dY\xd1\x90\x15\x0dY\xd1\x90\x15\x0dY\xd1\x905\xcd\x9059j\xbc\x1b\xb5r\xf1\xc6\xac\xd1\xb7\xb5\xfeh\xbd\xfar\xadW\xc3\xab@\x1a\x0cX\x03\nBZmX3Y\xad\xfa\x89\x1d\xd05XU\xa1\x97&\xc8\xae\x92\xef\xb50\xb0Y\xccV\x93b\xd4\xa6\xe6r\x80I#3\xe7t\x80>\x9f~`,>6\x07\xc7\x82a%\x9d\x06\xfdH\x80G\x94\xe7a\x98\xa01\xdf\x03L'24\xe7\x03B\x8e\xdd\x98\xfb\x81O|\xa9\x16\xdd\xae\\9 \xdaSs\x1e\x88\xd6\xa0\x9b\x0b\x02\xdd|\x10\x80\x919!`\xd8}Gn\x08\x98\x0e\xc1\x9fs\xe0\xcc\x0f\x01\x0f~\x83\x07\xc7\xc1\x87\xe7\x10p\xe8`X\xd8\xf1sF\xc0\x84\x9c\x01\xb9#0\xd3\x8a\x8e\x97C\x02\x96\x95y\x124f\xcc'\x81\x00\xb0\x82\x00\xd0\xc26\xde\xdc\x12\x08<\x11l\xe7\xcb1\x010\xdd\xbcl\xbc\x8d\xf9\x89\xeb{\xb0\x01\xed\x8bN\xdc\x86(\xff>^\xf9\xb7\x03h\x16\xd93\xb0`Q\x05\n\xfa\xcdy\xf0\x03\xe5hc\xed\x13\xb434\xe8\xb3$;\xac\x11\x9a\xe5\xd4+\x03\x8dZ\xdc\xa6\xc8wK\xe6\\_H\x1eU?\xefd\x1eyz\xc6\xe4\xa91\xa5\xd5-\xdc\xc7O\xe9\x86\xe6]\xcbO_Pu\xf3\xf5\x11\xf3\x18#\xc3\x9b&\xe6\x90\xe3\xbd\x92\xbcS\x96\xf7J\xf3f\xc6\xfa\xc8$z\xd3\x96\xd9\xa4\xfa\x99\xe4\xfa p\xb0\xca\xf6\xa3\xa4{\x9f|\x1f \xe1;e|\x83\x94?A\xce7\xe2\x97[\xd6?\x8e\xb4\xef#J\xe0%L\xe0\xa7\x0d\x10\x04\x10`X\xe2i\xe4~#\x1a\x07\xca\xfes\xad\xec\xb8\xf2\xbfm\x85\x1eAzv- \x04\xdc \x08\xe4\xb0U\x90.\x10zB\xd82D\x1f0k\x043\xe9 \x1d\x99\xe0\x94\xd9\xe9\x86\x19t\xc7\xef\xdc\x8e\xae G5 \xc4\xcb\xd1c9\xdaX\x8e\xf6\xe8\xe5h5\xb4\x9a\xa2t\xbatN \x957Y\x9e|\xac\xae\x0eo\xc6W\x7f\x85\xaa\x97a5\x00z\xfa\xa5\xf7j\xf6\x86\xe9]uDZ\xdb\x06\xf4\xe5N\xaf\xe8v\xd6m\xda\x911\xad\x92\xa5A\x9e\xfcU\xdb\xb0`\xd9\xd1\xb6\xc9\xed\xc0\xfbt\xd3f\x01)\xc62\xe5\xac\x16\xdbe\xb8\xa5P\x18dM\xf1\x97K&F<\x035\xf33\x10\xff\x17*Fk*\x12\xb4_\x80g\x96/\xe1\x8d\n\xd9\xc0ii\xaf\x88\x17^\xc2\xab\xae\x90#\xd0\xe8o\x07\x8e\xbaE\x81\xe6\xab-\x85|O1\xb2oK\xd8\x9ao\xc9G\xba\xd0:R\xf3\xb4\xf4E\x92\x8f,\xbf\xcf\xe8\xfaV\xf5U\xf7\x01\xbc\xa4{\x93P\x85\x8aU\xca\xf41\x1c\x03$\xf9n\x9f\xd1\xb2\xdb\xbb\x01.\xcb\x820\xbe\xa1\xc5\xe2\x0de\xf9\xee\xba \xc9$#\xc4P\xe3U\x07L0Z\xbaUX\x0eE\xc9|\x03\xfb\xbc(\xbfU\xba\xa5f\x0d\xe0Z\xd4eA\x12\xa9bRPQ\xe2\x154\x1d\xd8mz\x93\xd1%+\xf3\x8f\xd4\xc6\xf3o\x08\xa7\xab\xb5\xd8\x85 \x0b\x10\x9d\x00vR \x07j\x0e\x05\xcd\xc8\x83\x98\xa9\x9a\x0b\xf4\xa6\xe2\xa3S\xcd\x01\xb5\xe3[\xfaC\x8a\xdd\xb8x}\xf5\xdd\xbftF\xe3\xb5\x1dK\xed\x8f\xda\xb2%K\x99$\xb4U\x91\x1b\x17\xa0\\\x92\x82\xb4\xcc\x10\x83\x81\x84S\xb6^Q&\xf8\xaf5\xe0\xe1&\xcf3J\x98\x8d\x1b\x18\x1fw+\xf9h\xc3\x80\xfc\x17\xad\x12\xeb\x94\xcb\xbfI\x96AR\xe4\x9c\xbf\x90`\x86\x9b\x04\xd5ByU\xc0[(\xa6\x0eY\xb1\xa0 M\xef\xe8 \x16\xd4\x19i\xd4\x9a0t\xc6\xb4\"\x1f\xf8\xc9co!'\xa7(b_\xfc\xf0\xba\x1e\x00\xf6\xa2\x19-i\xc1\x17K&m\xf9\xd7\xb9P\xc1\xee\xd0\x84\x06d\xf4\x1b\x0eW\x94\xad\xfboW\\\xbc\x856e\x0e\x1b\x92q'\x95D\xb6\xdf`\xe2\x1cv[\x9c\xc3\xaa\xecP^\xd3\x11h-\xa1\xa0\xe5\xa1`\x95\x84\x82\x82\x1d]w\xd6\x83\x0d5\xd4\x9e\xa9\xc4\x9e\x81\xc6\x83\x87L\xc2#\xa0\xf5`PF\xac4\x1fF,h<\xed\x87\xae\xd6\x10\x8e\x96\x16\x80\x0c\x11^5\x86\xd2D\x01\x0d\x00\xfeY\xbc\x16\x1aL\x7ff\xb7\x85\x05\xac\xfdp\xf08@\xdbd\xa8u\x82\xf7\x98\x85M\x03\xf1\x81&\xa4\xcf \xf0\x18\xe6\xe5 \xc2\xbc\xa6\xc2\x82\xeb\xea3\xe2&\xe2\xfb\xc4\xd0\xbf\xc3\xd2\xd4\x83\xa9\xda\xde\xa4C\x96\xf6\xb3\n\xf9\xaeP~&j\x1f\xcdQ\xbe\xb5}I\xe6\xa8'\xdd\xbf\x8eb\x16\xd1x\xc4\x10\xd6\"E\xcc9\xb8\xca\xbe\xab\xa3\x98V\xb8\xefK\xb4\x8d\xf4Z\x116)H\xce\x84K\x0e\xc5\xa7\xd5\xafI\x19\x00\xf0\xea\x0b`X\xe4\x11\x95 0\xa0\x93[\x19\x82#-\xf2\x98\x8a\x11LD\xa16P\x87`\x8f\xd2\xb4\xfa\x88\xf3D\xfc\xf7\xfb\xff \x00\x00\xff\xffPK\x07\x08\xfc\x88'\x07e\xb2\x00\x00\xe0\xb0\n\x00PK\x01\x02\x14\x03\x14\x00\x08\x00\x08\x00\x00\x00!(\xfc\xe6\xfc\x06u\x01\x00\x00\xe4 \x00\x00\x0b\x00 \x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x00\x00\x00\x00config.jsonUT\x05\x00\x01\x80Cm8PK\x01\x02\x14\x03\x14\x00\x08\x00\x08\x00\x00\x00!(\xfc\x88'\x07e\xb2\x00\x00\xe0\xb0\n\x00\x0c\x00 \x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xb7\x01\x00\x00swagger.jsonUT\x05\x00\x01\x80Cm8PK\x05\x06\x00\x00\x00\x00\x02\x00\x02\x00\x85\x00\x00\x00_\xb4\x00\x00\x00\x00" + fs.Register(data) +}