nibiru_std/proto/buf/
cosmos.base.reflection.v2alpha1.rs

1// @generated
2/// AppDescriptor describes a cosmos-sdk based application
3#[allow(clippy::derive_partial_eq_without_eq)]
4#[derive(Clone, PartialEq, ::prost::Message)]
5pub struct AppDescriptor {
6    /// AuthnDescriptor provides information on how to authenticate transactions on the application
7    /// NOTE: experimental and subject to change in future releases.
8    #[prost(message, optional, tag="1")]
9    pub authn: ::core::option::Option<AuthnDescriptor>,
10    /// chain provides the chain descriptor
11    #[prost(message, optional, tag="2")]
12    pub chain: ::core::option::Option<ChainDescriptor>,
13    /// codec provides metadata information regarding codec related types
14    #[prost(message, optional, tag="3")]
15    pub codec: ::core::option::Option<CodecDescriptor>,
16    /// configuration provides metadata information regarding the sdk.Config type
17    #[prost(message, optional, tag="4")]
18    pub configuration: ::core::option::Option<ConfigurationDescriptor>,
19    /// query_services provides metadata information regarding the available queriable endpoints
20    #[prost(message, optional, tag="5")]
21    pub query_services: ::core::option::Option<QueryServicesDescriptor>,
22    /// tx provides metadata information regarding how to send transactions to the given application
23    #[prost(message, optional, tag="6")]
24    pub tx: ::core::option::Option<TxDescriptor>,
25}
26/// TxDescriptor describes the accepted transaction type
27#[allow(clippy::derive_partial_eq_without_eq)]
28#[derive(Clone, PartialEq, ::prost::Message)]
29pub struct TxDescriptor {
30    /// fullname is the protobuf fullname of the raw transaction type (for instance the tx.Tx type)
31    /// it is not meant to support polymorphism of transaction types, it is supposed to be used by
32    /// reflection clients to understand if they can handle a specific transaction type in an application.
33    #[prost(string, tag="1")]
34    pub fullname: ::prost::alloc::string::String,
35    /// msgs lists the accepted application messages (sdk.Msg)
36    #[prost(message, repeated, tag="2")]
37    pub msgs: ::prost::alloc::vec::Vec<MsgDescriptor>,
38}
39/// AuthnDescriptor provides information on how to sign transactions without relying
40/// on the online RPCs GetTxMetadata and CombineUnsignedTxAndSignatures
41#[allow(clippy::derive_partial_eq_without_eq)]
42#[derive(Clone, PartialEq, ::prost::Message)]
43pub struct AuthnDescriptor {
44    /// sign_modes defines the supported signature algorithm
45    #[prost(message, repeated, tag="1")]
46    pub sign_modes: ::prost::alloc::vec::Vec<SigningModeDescriptor>,
47}
48/// SigningModeDescriptor provides information on a signing flow of the application
49/// NOTE(fdymylja): here we could go as far as providing an entire flow on how
50/// to sign a message given a SigningModeDescriptor, but it's better to think about
51/// this another time
52#[allow(clippy::derive_partial_eq_without_eq)]
53#[derive(Clone, PartialEq, ::prost::Message)]
54pub struct SigningModeDescriptor {
55    /// name defines the unique name of the signing mode
56    #[prost(string, tag="1")]
57    pub name: ::prost::alloc::string::String,
58    /// number is the unique int32 identifier for the sign_mode enum
59    #[prost(int32, tag="2")]
60    pub number: i32,
61    /// authn_info_provider_method_fullname defines the fullname of the method to call to get
62    /// the metadata required to authenticate using the provided sign_modes
63    #[prost(string, tag="3")]
64    pub authn_info_provider_method_fullname: ::prost::alloc::string::String,
65}
66/// ChainDescriptor describes chain information of the application
67#[allow(clippy::derive_partial_eq_without_eq)]
68#[derive(Clone, PartialEq, ::prost::Message)]
69pub struct ChainDescriptor {
70    /// id is the chain id
71    #[prost(string, tag="1")]
72    pub id: ::prost::alloc::string::String,
73}
74/// CodecDescriptor describes the registered interfaces and provides metadata information on the types
75#[allow(clippy::derive_partial_eq_without_eq)]
76#[derive(Clone, PartialEq, ::prost::Message)]
77pub struct CodecDescriptor {
78    /// interfaces is a list of the registerted interfaces descriptors
79    #[prost(message, repeated, tag="1")]
80    pub interfaces: ::prost::alloc::vec::Vec<InterfaceDescriptor>,
81}
82/// InterfaceDescriptor describes the implementation of an interface
83#[allow(clippy::derive_partial_eq_without_eq)]
84#[derive(Clone, PartialEq, ::prost::Message)]
85pub struct InterfaceDescriptor {
86    /// fullname is the name of the interface
87    #[prost(string, tag="1")]
88    pub fullname: ::prost::alloc::string::String,
89    /// interface_accepting_messages contains information regarding the proto messages which contain the interface as
90    /// google.protobuf.Any field
91    #[prost(message, repeated, tag="2")]
92    pub interface_accepting_messages: ::prost::alloc::vec::Vec<InterfaceAcceptingMessageDescriptor>,
93    /// interface_implementers is a list of the descriptors of the interface implementers
94    #[prost(message, repeated, tag="3")]
95    pub interface_implementers: ::prost::alloc::vec::Vec<InterfaceImplementerDescriptor>,
96}
97/// InterfaceImplementerDescriptor describes an interface implementer
98#[allow(clippy::derive_partial_eq_without_eq)]
99#[derive(Clone, PartialEq, ::prost::Message)]
100pub struct InterfaceImplementerDescriptor {
101    /// fullname is the protobuf queryable name of the interface implementer
102    #[prost(string, tag="1")]
103    pub fullname: ::prost::alloc::string::String,
104    /// type_url defines the type URL used when marshalling the type as any
105    /// this is required so we can provide type safe google.protobuf.Any marshalling and
106    /// unmarshalling, making sure that we don't accept just 'any' type
107    /// in our interface fields
108    #[prost(string, tag="2")]
109    pub type_url: ::prost::alloc::string::String,
110}
111/// InterfaceAcceptingMessageDescriptor describes a protobuf message which contains
112/// an interface represented as a google.protobuf.Any
113#[allow(clippy::derive_partial_eq_without_eq)]
114#[derive(Clone, PartialEq, ::prost::Message)]
115pub struct InterfaceAcceptingMessageDescriptor {
116    /// fullname is the protobuf fullname of the type containing the interface
117    #[prost(string, tag="1")]
118    pub fullname: ::prost::alloc::string::String,
119    /// field_descriptor_names is a list of the protobuf name (not fullname) of the field
120    /// which contains the interface as google.protobuf.Any (the interface is the same, but
121    /// it can be in multiple fields of the same proto message)
122    #[prost(string, repeated, tag="2")]
123    pub field_descriptor_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
124}
125/// ConfigurationDescriptor contains metadata information on the sdk.Config
126#[allow(clippy::derive_partial_eq_without_eq)]
127#[derive(Clone, PartialEq, ::prost::Message)]
128pub struct ConfigurationDescriptor {
129    /// bech32_account_address_prefix is the account address prefix
130    #[prost(string, tag="1")]
131    pub bech32_account_address_prefix: ::prost::alloc::string::String,
132}
133/// MsgDescriptor describes a cosmos-sdk message that can be delivered with a transaction
134#[allow(clippy::derive_partial_eq_without_eq)]
135#[derive(Clone, PartialEq, ::prost::Message)]
136pub struct MsgDescriptor {
137    /// msg_type_url contains the TypeURL of a sdk.Msg.
138    #[prost(string, tag="1")]
139    pub msg_type_url: ::prost::alloc::string::String,
140}
141/// GetAuthnDescriptorRequest is the request used for the GetAuthnDescriptor RPC
142#[allow(clippy::derive_partial_eq_without_eq)]
143#[derive(Clone, PartialEq, ::prost::Message)]
144pub struct GetAuthnDescriptorRequest {
145}
146/// GetAuthnDescriptorResponse is the response returned by the GetAuthnDescriptor RPC
147#[allow(clippy::derive_partial_eq_without_eq)]
148#[derive(Clone, PartialEq, ::prost::Message)]
149pub struct GetAuthnDescriptorResponse {
150    /// authn describes how to authenticate to the application when sending transactions
151    #[prost(message, optional, tag="1")]
152    pub authn: ::core::option::Option<AuthnDescriptor>,
153}
154/// GetChainDescriptorRequest is the request used for the GetChainDescriptor RPC
155#[allow(clippy::derive_partial_eq_without_eq)]
156#[derive(Clone, PartialEq, ::prost::Message)]
157pub struct GetChainDescriptorRequest {
158}
159/// GetChainDescriptorResponse is the response returned by the GetChainDescriptor RPC
160#[allow(clippy::derive_partial_eq_without_eq)]
161#[derive(Clone, PartialEq, ::prost::Message)]
162pub struct GetChainDescriptorResponse {
163    /// chain describes application chain information
164    #[prost(message, optional, tag="1")]
165    pub chain: ::core::option::Option<ChainDescriptor>,
166}
167/// GetCodecDescriptorRequest is the request used for the GetCodecDescriptor RPC
168#[allow(clippy::derive_partial_eq_without_eq)]
169#[derive(Clone, PartialEq, ::prost::Message)]
170pub struct GetCodecDescriptorRequest {
171}
172/// GetCodecDescriptorResponse is the response returned by the GetCodecDescriptor RPC
173#[allow(clippy::derive_partial_eq_without_eq)]
174#[derive(Clone, PartialEq, ::prost::Message)]
175pub struct GetCodecDescriptorResponse {
176    /// codec describes the application codec such as registered interfaces and implementations
177    #[prost(message, optional, tag="1")]
178    pub codec: ::core::option::Option<CodecDescriptor>,
179}
180/// GetConfigurationDescriptorRequest is the request used for the GetConfigurationDescriptor RPC
181#[allow(clippy::derive_partial_eq_without_eq)]
182#[derive(Clone, PartialEq, ::prost::Message)]
183pub struct GetConfigurationDescriptorRequest {
184}
185/// GetConfigurationDescriptorResponse is the response returned by the GetConfigurationDescriptor RPC
186#[allow(clippy::derive_partial_eq_without_eq)]
187#[derive(Clone, PartialEq, ::prost::Message)]
188pub struct GetConfigurationDescriptorResponse {
189    /// config describes the application's sdk.Config
190    #[prost(message, optional, tag="1")]
191    pub config: ::core::option::Option<ConfigurationDescriptor>,
192}
193/// GetQueryServicesDescriptorRequest is the request used for the GetQueryServicesDescriptor RPC
194#[allow(clippy::derive_partial_eq_without_eq)]
195#[derive(Clone, PartialEq, ::prost::Message)]
196pub struct GetQueryServicesDescriptorRequest {
197}
198/// GetQueryServicesDescriptorResponse is the response returned by the GetQueryServicesDescriptor RPC
199#[allow(clippy::derive_partial_eq_without_eq)]
200#[derive(Clone, PartialEq, ::prost::Message)]
201pub struct GetQueryServicesDescriptorResponse {
202    /// queries provides information on the available queryable services
203    #[prost(message, optional, tag="1")]
204    pub queries: ::core::option::Option<QueryServicesDescriptor>,
205}
206/// GetTxDescriptorRequest is the request used for the GetTxDescriptor RPC
207#[allow(clippy::derive_partial_eq_without_eq)]
208#[derive(Clone, PartialEq, ::prost::Message)]
209pub struct GetTxDescriptorRequest {
210}
211/// GetTxDescriptorResponse is the response returned by the GetTxDescriptor RPC
212#[allow(clippy::derive_partial_eq_without_eq)]
213#[derive(Clone, PartialEq, ::prost::Message)]
214pub struct GetTxDescriptorResponse {
215    /// tx provides information on msgs that can be forwarded to the application
216    /// alongside the accepted transaction protobuf type
217    #[prost(message, optional, tag="1")]
218    pub tx: ::core::option::Option<TxDescriptor>,
219}
220/// QueryServicesDescriptor contains the list of cosmos-sdk queriable services
221#[allow(clippy::derive_partial_eq_without_eq)]
222#[derive(Clone, PartialEq, ::prost::Message)]
223pub struct QueryServicesDescriptor {
224    /// query_services is a list of cosmos-sdk QueryServiceDescriptor
225    #[prost(message, repeated, tag="1")]
226    pub query_services: ::prost::alloc::vec::Vec<QueryServiceDescriptor>,
227}
228/// QueryServiceDescriptor describes a cosmos-sdk queryable service
229#[allow(clippy::derive_partial_eq_without_eq)]
230#[derive(Clone, PartialEq, ::prost::Message)]
231pub struct QueryServiceDescriptor {
232    /// fullname is the protobuf fullname of the service descriptor
233    #[prost(string, tag="1")]
234    pub fullname: ::prost::alloc::string::String,
235    /// is_module describes if this service is actually exposed by an application's module
236    #[prost(bool, tag="2")]
237    pub is_module: bool,
238    /// methods provides a list of query service methods
239    #[prost(message, repeated, tag="3")]
240    pub methods: ::prost::alloc::vec::Vec<QueryMethodDescriptor>,
241}
242/// QueryMethodDescriptor describes a queryable method of a query service
243/// no other info is provided beside method name and tendermint queryable path
244/// because it would be redundant with the grpc reflection service
245#[allow(clippy::derive_partial_eq_without_eq)]
246#[derive(Clone, PartialEq, ::prost::Message)]
247pub struct QueryMethodDescriptor {
248    /// name is the protobuf name (not fullname) of the method
249    #[prost(string, tag="1")]
250    pub name: ::prost::alloc::string::String,
251    /// full_query_path is the path that can be used to query
252    /// this method via tendermint abci.Query
253    #[prost(string, tag="2")]
254    pub full_query_path: ::prost::alloc::string::String,
255}
256// @@protoc_insertion_point(module)