From d917485b0e0eeadaa2ac8a611b66282849382fb0 Mon Sep 17 00:00:00 2001 From: Romain Ruetschi Date: Fri, 12 Apr 2024 10:39:22 +0200 Subject: [PATCH 1/3] Re-generate protos --- src/prost/google.protobuf.rs | 219 ++++++++++---- src/prost/google.protobuf.serde.rs | 442 ++++++++++++++++++++++++----- src/prost/proto_descriptor.bin | Bin 758331 -> 761618 bytes 3 files changed, 536 insertions(+), 125 deletions(-) diff --git a/src/prost/google.protobuf.rs b/src/prost/google.protobuf.rs index a0dfa109..3f43790e 100644 --- a/src/prost/google.protobuf.rs +++ b/src/prost/google.protobuf.rs @@ -192,9 +192,9 @@ pub struct FileDescriptorProto { /// If `edition` is present, this value must be "editions". #[prost(string, optional, tag = "12")] pub syntax: ::core::option::Option<::prost::alloc::string::String>, - /// The edition of the proto file, which is an opaque string. - #[prost(string, optional, tag = "13")] - pub edition: ::core::option::Option<::prost::alloc::string::String>, + /// The edition of the proto file. + #[prost(enumeration = "Edition", optional, tag = "14")] + pub edition: ::core::option::Option, } impl ::prost::Name for FileDescriptorProto { const NAME: &'static str = "FileDescriptorProto"; @@ -294,7 +294,7 @@ pub struct ExtensionRangeOptions { #[prost(message, optional, tag = "50")] pub features: ::core::option::Option, /// The verification state of the range. - /// TODO(b/278783756): flip the default to DECLARATION once all empty ranges + /// TODO: flip the default to DECLARATION once all empty ranges /// are marked as UNVERIFIED. #[prost( enumeration = "extension_range_options::VerificationState", @@ -432,12 +432,12 @@ pub struct FieldDescriptorProto { /// If true, this is a proto3 "optional". When a proto3 field is optional, it /// tracks presence regardless of field type. /// - /// When proto3_optional is true, this field must be belong to a oneof to - /// signal to old proto3 clients that presence is tracked for this field. This - /// oneof is known as a "synthetic" oneof, and this field must be its sole - /// member (each proto3 optional field gets its own synthetic oneof). Synthetic - /// oneofs exist in the descriptor only, and do not generate any API. Synthetic - /// oneofs must be ordered after all "real" oneofs. + /// When proto3_optional is true, this field must belong to a oneof to signal + /// to old proto3 clients that presence is tracked for this field. This oneof + /// is known as a "synthetic" oneof, and this field must be its sole member + /// (each proto3 optional field gets its own synthetic oneof). Synthetic oneofs + /// exist in the descriptor only, and do not generate any API. Synthetic oneofs + /// must be ordered after all "real" oneofs. /// /// For message fields, proto3_optional doesn't create any semantic change, /// since non-repeated message fields always track presence. However it still @@ -484,9 +484,10 @@ pub mod field_descriptor_proto { Bool = 8, String = 9, /// Tag-delimited aggregate. - /// Group type is deprecated and not supported in proto3. However, Proto3 + /// Group type is deprecated and not supported after google.protobuf. However, Proto3 /// implementations should still be able to parse the group wire format and - /// treat group fields as unknown fields. + /// treat group fields as unknown fields. In Editions, the group wire format + /// can be enabled via the `message_encoding` feature. Group = 10, /// Length-delimited aggregate. Message = 11, @@ -568,8 +569,11 @@ pub mod field_descriptor_proto { pub enum Label { /// 0 is reserved for errors Optional = 1, - Required = 2, Repeated = 3, + /// The required label is only allowed in google.protobuf. In proto3 and Editions + /// it's explicitly prohibited. In Editions, the `field_presence` feature + /// can be used to get this behavior. + Required = 2, } impl Label { /// String value of the enum field names used in the ProtoBuf definition. @@ -579,16 +583,16 @@ pub mod field_descriptor_proto { pub fn as_str_name(&self) -> &'static str { match self { Label::Optional => "LABEL_OPTIONAL", - Label::Required => "LABEL_REQUIRED", Label::Repeated => "LABEL_REPEATED", + Label::Required => "LABEL_REQUIRED", } } /// Creates an enum from field names used in the ProtoBuf definition. pub fn from_str_name(value: &str) -> ::core::option::Option { match value { "LABEL_OPTIONAL" => Some(Self::Optional), - "LABEL_REQUIRED" => Some(Self::Required), "LABEL_REPEATED" => Some(Self::Repeated), + "LABEL_REQUIRED" => Some(Self::Required), _ => None, } } @@ -802,8 +806,6 @@ pub struct FileOptions { pub java_generic_services: ::core::option::Option, #[prost(bool, optional, tag = "18", default = "false")] pub py_generic_services: ::core::option::Option, - #[prost(bool, optional, tag = "42", default = "false")] - pub php_generic_services: ::core::option::Option, /// Is this file deprecated? /// Depending on the target platform, this can emit Deprecated annotations /// for everything in the file, or it will be completely ignored; in the very @@ -943,10 +945,6 @@ pub struct MessageOptions { /// this is a formalization for deprecating messages. #[prost(bool, optional, tag = "3", default = "false")] pub deprecated: ::core::option::Option, - /// NOTE: Do not set the option in .proto files. Always use the maps syntax - /// instead. The option should only be implicitly set by the proto compiler - /// parser. - /// /// Whether the message is an automatically generated map entry type for the /// maps field. /// @@ -964,6 +962,10 @@ pub struct MessageOptions { /// use a native map in the target language to hold the keys and values. /// The reflection APIs in such implementations still need to work as /// if the field is a repeated message field. + /// + /// NOTE: Do not set the option in .proto files. Always use the maps syntax + /// instead. The option should only be implicitly set by the proto compiler + /// parser. #[prost(bool, optional, tag = "7")] pub map_entry: ::core::option::Option, /// Enable the legacy handling of JSON field name conflicts. This lowercases @@ -974,7 +976,7 @@ pub struct MessageOptions { /// This should only be used as a temporary measure against broken builds due /// to the change in behavior for JSON field name conflicts. /// - /// TODO(b/261750190) This is legacy behavior we plan to remove once downstream + /// TODO This is legacy behavior we plan to remove once downstream /// teams have had time to migrate. #[deprecated] #[prost(bool, optional, tag = "11")] @@ -1013,7 +1015,9 @@ pub struct FieldOptions { /// a more efficient representation on the wire. Rather than repeatedly /// writing the tag and type for each element, the entire array is encoded as /// a single length-delimited blob. In proto3, only explicit setting it to - /// false will avoid using packed encoding. + /// false will avoid using packed encoding. This option is prohibited in + /// Editions, but the `repeated_field_encoding` feature can be used to control + /// the behavior. #[prost(bool, optional, tag = "2")] pub packed: ::core::option::Option, /// The jstype option determines the JavaScript type used for values of the @@ -1051,19 +1055,11 @@ pub struct FieldOptions { /// call from multiple threads concurrently, while non-const methods continue /// to require exclusive access. /// - /// Note that implementations may choose not to check required fields within - /// a lazy sub-message. That is, calling IsInitialized() on the outer message - /// may return true even if the inner message has missing required fields. - /// This is necessary because otherwise the inner message would have to be - /// parsed in order to perform the check, defeating the purpose of lazy - /// parsing. An implementation which chooses not to check required fields - /// must be consistent about it. That is, for any particular sub-message, the - /// implementation must either *always* check its required fields, or *never* - /// check its required fields, regardless of whether or not the message has - /// been parsed. - /// - /// As of May 2022, lazy verifies the contents of the byte stream during - /// parsing. An invalid byte stream will cause the overall parsing to fail. + /// Note that lazy message fields are still eagerly verified to check + /// ill-formed wireformat or missing required fields. Calling IsInitialized() + /// on the outer message would fail if the inner message has missing required + /// fields. Failed verification would result in parsing failure (except when + /// uninitialized messages are acceptable). #[prost(bool, optional, tag = "5", default = "false")] pub lazy: ::core::option::Option, /// unverified_lazy does no correctness checks on the byte stream. This should @@ -1107,8 +1103,8 @@ pub mod field_options { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct EditionDefault { - #[prost(string, optional, tag = "1")] - pub edition: ::core::option::Option<::prost::alloc::string::String>, + #[prost(enumeration = "super::Edition", optional, tag = "3")] + pub edition: ::core::option::Option, /// Textproto value. #[prost(string, optional, tag = "2")] pub value: ::core::option::Option<::prost::alloc::string::String>, @@ -1358,7 +1354,7 @@ pub struct EnumOptions { /// and strips underscored from the fields before comparison in proto3 only. /// The new behavior takes `json_name` into account and applies to proto2 as /// well. - /// TODO(b/261750190) Remove this legacy behavior once downstream teams have + /// TODO Remove this legacy behavior once downstream teams have /// had time to migrate. #[deprecated] #[prost(bool, optional, tag = "6")] @@ -1561,7 +1557,7 @@ impl ::prost::Name for UninterpretedOption { ::prost::alloc::format!("google.protobuf.{}", Self::NAME) } } -/// TODO(b/274655146) Enums in C++ gencode (and potentially other languages) are +/// TODO Enums in C++ gencode (and potentially other languages) are /// not well scoped. This means that each of the feature enums below can clash /// with each other. The short names we've chosen maximize call-site /// readability, but leave us very open to this scenario. A future feature will @@ -1576,14 +1572,12 @@ pub struct FeatureSet { pub enum_type: ::core::option::Option, #[prost(enumeration = "feature_set::RepeatedFieldEncoding", optional, tag = "3")] pub repeated_field_encoding: ::core::option::Option, - #[prost(enumeration = "feature_set::StringFieldValidation", optional, tag = "4")] - pub string_field_validation: ::core::option::Option, + #[prost(enumeration = "feature_set::Utf8Validation", optional, tag = "4")] + pub utf8_validation: ::core::option::Option, #[prost(enumeration = "feature_set::MessageEncoding", optional, tag = "5")] pub message_encoding: ::core::option::Option, #[prost(enumeration = "feature_set::JsonFormat", optional, tag = "6")] pub json_format: ::core::option::Option, - #[prost(message, optional, boxed, tag = "999")] - pub raw_features: ::core::option::Option<::prost::alloc::boxed::Box>, } /// Nested message and enum types in `FeatureSet`. pub mod feature_set { @@ -1719,31 +1713,28 @@ pub mod feature_set { ::prost::Enumeration )] #[repr(i32)] - pub enum StringFieldValidation { + pub enum Utf8Validation { Unknown = 0, - Mandatory = 1, - Hint = 2, + Verify = 2, None = 3, } - impl StringFieldValidation { + impl Utf8Validation { /// String value of the enum field names used in the ProtoBuf definition. /// /// The values are not transformed in any way and thus are considered stable /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - StringFieldValidation::Unknown => "STRING_FIELD_VALIDATION_UNKNOWN", - StringFieldValidation::Mandatory => "MANDATORY", - StringFieldValidation::Hint => "HINT", - StringFieldValidation::None => "NONE", + Utf8Validation::Unknown => "UTF8_VALIDATION_UNKNOWN", + Utf8Validation::Verify => "VERIFY", + Utf8Validation::None => "NONE", } } /// Creates an enum from field names used in the ProtoBuf definition. pub fn from_str_name(value: &str) -> ::core::option::Option { match value { - "STRING_FIELD_VALIDATION_UNKNOWN" => Some(Self::Unknown), - "MANDATORY" => Some(Self::Mandatory), - "HINT" => Some(Self::Hint), + "UTF8_VALIDATION_UNKNOWN" => Some(Self::Unknown), + "VERIFY" => Some(Self::Verify), "NONE" => Some(Self::None), _ => None, } @@ -1835,6 +1826,55 @@ impl ::prost::Name for FeatureSet { ::prost::alloc::format!("google.protobuf.{}", Self::NAME) } } +/// A compiled specification for the defaults of a set of features. These +/// messages are generated from FeatureSet extensions and can be used to seed +/// feature resolution. The resolution with this object becomes a simple search +/// for the closest matching edition, followed by proto merges. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FeatureSetDefaults { + #[prost(message, repeated, tag = "1")] + pub defaults: ::prost::alloc::vec::Vec< + feature_set_defaults::FeatureSetEditionDefault, + >, + /// The minimum supported edition (inclusive) when this was constructed. + /// Editions before this will not have defaults. + #[prost(enumeration = "Edition", optional, tag = "4")] + pub minimum_edition: ::core::option::Option, + /// The maximum known edition (inclusive) when this was constructed. Editions + /// after this will not have reliable defaults. + #[prost(enumeration = "Edition", optional, tag = "5")] + pub maximum_edition: ::core::option::Option, +} +/// Nested message and enum types in `FeatureSetDefaults`. +pub mod feature_set_defaults { + /// A map from every known edition with a unique set of defaults to its + /// defaults. Not all editions may be contained here. For a given edition, + /// the defaults at the closest matching edition ordered at or before it should + /// be used. This field must be in strict ascending order by edition. + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct FeatureSetEditionDefault { + #[prost(enumeration = "super::Edition", optional, tag = "3")] + pub edition: ::core::option::Option, + #[prost(message, optional, tag = "2")] + pub features: ::core::option::Option, + } + impl ::prost::Name for FeatureSetEditionDefault { + const NAME: &'static str = "FeatureSetEditionDefault"; + const PACKAGE: &'static str = "google.protobuf"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("google.protobuf.FeatureSetDefaults.{}", Self::NAME) + } + } +} +impl ::prost::Name for FeatureSetDefaults { + const NAME: &'static str = "FeatureSetDefaults"; + const PACKAGE: &'static str = "google.protobuf"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + } +} /// Encapsulates information about the original source file from which a /// FileDescriptorProto was generated. #[allow(clippy::derive_partial_eq_without_eq)] @@ -1895,7 +1935,7 @@ pub mod source_code_info { /// location. /// /// Each element is a field number or an index. They form a path from - /// the root FileDescriptorProto to the place where the definition occurs. + /// the root FileDescriptorProto to the place where the definition appears. /// For example, this path: /// \[ 4, 3, 2, 7, 1 \] /// refers to: @@ -2091,6 +2131,73 @@ impl ::prost::Name for GeneratedCodeInfo { ::prost::alloc::format!("google.protobuf.{}", Self::NAME) } } +/// The full set of known editions. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum Edition { + /// A placeholder for an unknown edition value. + Unknown = 0, + /// Legacy syntax "editions". These pre-date editions, but behave much like + /// distinct editions. These can't be used to specify the edition of proto + /// files, but feature definitions must supply proto2/proto3 defaults for + /// backwards compatibility. + Proto2 = 998, + Proto3 = 999, + /// Editions that have been released. The specific values are arbitrary and + /// should not be depended on, but they will always be time-ordered for easy + /// comparison. + Edition2023 = 1000, + Edition2024 = 1001, + /// Placeholder editions for testing feature resolution. These should not be + /// used or relyed on outside of tests. + Edition1TestOnly = 1, + Edition2TestOnly = 2, + Edition99997TestOnly = 99997, + Edition99998TestOnly = 99998, + Edition99999TestOnly = 99999, + /// Placeholder for specifying unbounded edition support. This should only + /// ever be used by plugins that can expect to never require any changes to + /// support a new edition. + Max = 2147483647, +} +impl Edition { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Edition::Unknown => "EDITION_UNKNOWN", + Edition::Proto2 => "EDITION_PROTO2", + Edition::Proto3 => "EDITION_PROTO3", + Edition::Edition2023 => "EDITION_2023", + Edition::Edition2024 => "EDITION_2024", + Edition::Edition1TestOnly => "EDITION_1_TEST_ONLY", + Edition::Edition2TestOnly => "EDITION_2_TEST_ONLY", + Edition::Edition99997TestOnly => "EDITION_99997_TEST_ONLY", + Edition::Edition99998TestOnly => "EDITION_99998_TEST_ONLY", + Edition::Edition99999TestOnly => "EDITION_99999_TEST_ONLY", + Edition::Max => "EDITION_MAX", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "EDITION_UNKNOWN" => Some(Self::Unknown), + "EDITION_PROTO2" => Some(Self::Proto2), + "EDITION_PROTO3" => Some(Self::Proto3), + "EDITION_2023" => Some(Self::Edition2023), + "EDITION_2024" => Some(Self::Edition2024), + "EDITION_1_TEST_ONLY" => Some(Self::Edition1TestOnly), + "EDITION_2_TEST_ONLY" => Some(Self::Edition2TestOnly), + "EDITION_99997_TEST_ONLY" => Some(Self::Edition99997TestOnly), + "EDITION_99998_TEST_ONLY" => Some(Self::Edition99998TestOnly), + "EDITION_99999_TEST_ONLY" => Some(Self::Edition99999TestOnly), + "EDITION_MAX" => Some(Self::Max), + _ => None, + } + } +} /// A Timestamp represents a point in time independent of any time zone or local /// calendar, encoded as a count of seconds and fractions of seconds at /// nanosecond resolution. The count is relative to an epoch at UTC midnight on diff --git a/src/prost/google.protobuf.serde.rs b/src/prost/google.protobuf.serde.rs index 0c8064dd..4a8362c6 100644 --- a/src/prost/google.protobuf.serde.rs +++ b/src/prost/google.protobuf.serde.rs @@ -714,6 +714,104 @@ impl<'de> serde::Deserialize<'de> for Duration { deserializer.deserialize_struct("google.protobuf.Duration", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for Edition { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unknown => "EDITION_UNKNOWN", + Self::Proto2 => "EDITION_PROTO2", + Self::Proto3 => "EDITION_PROTO3", + Self::Edition2023 => "EDITION_2023", + Self::Edition2024 => "EDITION_2024", + Self::Edition1TestOnly => "EDITION_1_TEST_ONLY", + Self::Edition2TestOnly => "EDITION_2_TEST_ONLY", + Self::Edition99997TestOnly => "EDITION_99997_TEST_ONLY", + Self::Edition99998TestOnly => "EDITION_99998_TEST_ONLY", + Self::Edition99999TestOnly => "EDITION_99999_TEST_ONLY", + Self::Max => "EDITION_MAX", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for Edition { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "EDITION_UNKNOWN", + "EDITION_PROTO2", + "EDITION_PROTO3", + "EDITION_2023", + "EDITION_2024", + "EDITION_1_TEST_ONLY", + "EDITION_2_TEST_ONLY", + "EDITION_99997_TEST_ONLY", + "EDITION_99998_TEST_ONLY", + "EDITION_99999_TEST_ONLY", + "EDITION_MAX", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Edition; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> core::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> core::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "EDITION_UNKNOWN" => Ok(Edition::Unknown), + "EDITION_PROTO2" => Ok(Edition::Proto2), + "EDITION_PROTO3" => Ok(Edition::Proto3), + "EDITION_2023" => Ok(Edition::Edition2023), + "EDITION_2024" => Ok(Edition::Edition2024), + "EDITION_1_TEST_ONLY" => Ok(Edition::Edition1TestOnly), + "EDITION_2_TEST_ONLY" => Ok(Edition::Edition2TestOnly), + "EDITION_99997_TEST_ONLY" => Ok(Edition::Edition99997TestOnly), + "EDITION_99998_TEST_ONLY" => Ok(Edition::Edition99998TestOnly), + "EDITION_99999_TEST_ONLY" => Ok(Edition::Edition99999TestOnly), + "EDITION_MAX" => Ok(Edition::Max), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} impl serde::Serialize for EnumDescriptorProto { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result @@ -1824,9 +1922,6 @@ impl serde::Serialize for FeatureSet { if true { len += 1; } - if true { - len += 1; - } let mut struct_ser = serializer.serialize_struct("google.protobuf.FeatureSet", len)?; if let Some(v) = self.field_presence.as_ref() { let v = feature_set::FieldPresence::try_from(*v) @@ -1843,10 +1938,10 @@ impl serde::Serialize for FeatureSet { .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; struct_ser.serialize_field("repeatedFieldEncoding", &v)?; } - if let Some(v) = self.string_field_validation.as_ref() { - let v = feature_set::StringFieldValidation::try_from(*v) + if let Some(v) = self.utf8_validation.as_ref() { + let v = feature_set::Utf8Validation::try_from(*v) .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; - struct_ser.serialize_field("stringFieldValidation", &v)?; + struct_ser.serialize_field("utf8Validation", &v)?; } if let Some(v) = self.message_encoding.as_ref() { let v = feature_set::MessageEncoding::try_from(*v) @@ -1858,9 +1953,6 @@ impl serde::Serialize for FeatureSet { .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; struct_ser.serialize_field("jsonFormat", &v)?; } - if let Some(v) = self.raw_features.as_ref() { - struct_ser.serialize_field("rawFeatures", v)?; - } struct_ser.end() } } @@ -1877,14 +1969,12 @@ impl<'de> serde::Deserialize<'de> for FeatureSet { "enumType", "repeated_field_encoding", "repeatedFieldEncoding", - "string_field_validation", - "stringFieldValidation", + "utf8_validation", + "utf8Validation", "message_encoding", "messageEncoding", "json_format", "jsonFormat", - "raw_features", - "rawFeatures", ]; #[allow(clippy::enum_variant_names)] @@ -1892,10 +1982,9 @@ impl<'de> serde::Deserialize<'de> for FeatureSet { FieldPresence, EnumType, RepeatedFieldEncoding, - StringFieldValidation, + Utf8Validation, MessageEncoding, JsonFormat, - RawFeatures, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -1920,10 +2009,9 @@ impl<'de> serde::Deserialize<'de> for FeatureSet { "fieldPresence" | "field_presence" => Ok(GeneratedField::FieldPresence), "enumType" | "enum_type" => Ok(GeneratedField::EnumType), "repeatedFieldEncoding" | "repeated_field_encoding" => Ok(GeneratedField::RepeatedFieldEncoding), - "stringFieldValidation" | "string_field_validation" => Ok(GeneratedField::StringFieldValidation), + "utf8Validation" | "utf8_validation" => Ok(GeneratedField::Utf8Validation), "messageEncoding" | "message_encoding" => Ok(GeneratedField::MessageEncoding), "jsonFormat" | "json_format" => Ok(GeneratedField::JsonFormat), - "rawFeatures" | "raw_features" => Ok(GeneratedField::RawFeatures), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -1946,10 +2034,9 @@ impl<'de> serde::Deserialize<'de> for FeatureSet { let mut field_presence__ = None; let mut enum_type__ = None; let mut repeated_field_encoding__ = None; - let mut string_field_validation__ = None; + let mut utf8_validation__ = None; let mut message_encoding__ = None; let mut json_format__ = None; - let mut raw_features__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::FieldPresence => { @@ -1970,11 +2057,11 @@ impl<'de> serde::Deserialize<'de> for FeatureSet { } repeated_field_encoding__ = map_.next_value::<::core::option::Option>()?.map(|x| x as i32); } - GeneratedField::StringFieldValidation => { - if string_field_validation__.is_some() { - return Err(serde::de::Error::duplicate_field("stringFieldValidation")); + GeneratedField::Utf8Validation => { + if utf8_validation__.is_some() { + return Err(serde::de::Error::duplicate_field("utf8Validation")); } - string_field_validation__ = map_.next_value::<::core::option::Option>()?.map(|x| x as i32); + utf8_validation__ = map_.next_value::<::core::option::Option>()?.map(|x| x as i32); } GeneratedField::MessageEncoding => { if message_encoding__.is_some() { @@ -1988,22 +2075,15 @@ impl<'de> serde::Deserialize<'de> for FeatureSet { } json_format__ = map_.next_value::<::core::option::Option>()?.map(|x| x as i32); } - GeneratedField::RawFeatures => { - if raw_features__.is_some() { - return Err(serde::de::Error::duplicate_field("rawFeatures")); - } - raw_features__ = map_.next_value()?; - } } } Ok(FeatureSet { field_presence: field_presence__, enum_type: enum_type__, repeated_field_encoding: repeated_field_encoding__, - string_field_validation: string_field_validation__, + utf8_validation: utf8_validation__, message_encoding: message_encoding__, json_format: json_format__, - raw_features: raw_features__, }) } } @@ -2383,38 +2463,36 @@ impl<'de> serde::Deserialize<'de> for feature_set::RepeatedFieldEncoding { deserializer.deserialize_any(GeneratedVisitor) } } -impl serde::Serialize for feature_set::StringFieldValidation { +impl serde::Serialize for feature_set::Utf8Validation { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where S: serde::Serializer, { let variant = match self { - Self::Unknown => "STRING_FIELD_VALIDATION_UNKNOWN", - Self::Mandatory => "MANDATORY", - Self::Hint => "HINT", + Self::Unknown => "UTF8_VALIDATION_UNKNOWN", + Self::Verify => "VERIFY", Self::None => "NONE", }; serializer.serialize_str(variant) } } -impl<'de> serde::Deserialize<'de> for feature_set::StringFieldValidation { +impl<'de> serde::Deserialize<'de> for feature_set::Utf8Validation { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "STRING_FIELD_VALIDATION_UNKNOWN", - "MANDATORY", - "HINT", + "UTF8_VALIDATION_UNKNOWN", + "VERIFY", "NONE", ]; struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = feature_set::StringFieldValidation; + type Value = feature_set::Utf8Validation; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { write!(formatter, "expected one of: {:?}", &FIELDS) @@ -2449,10 +2527,9 @@ impl<'de> serde::Deserialize<'de> for feature_set::StringFieldValidation { E: serde::de::Error, { match value { - "STRING_FIELD_VALIDATION_UNKNOWN" => Ok(feature_set::StringFieldValidation::Unknown), - "MANDATORY" => Ok(feature_set::StringFieldValidation::Mandatory), - "HINT" => Ok(feature_set::StringFieldValidation::Hint), - "NONE" => Ok(feature_set::StringFieldValidation::None), + "UTF8_VALIDATION_UNKNOWN" => Ok(feature_set::Utf8Validation::Unknown), + "VERIFY" => Ok(feature_set::Utf8Validation::Verify), + "NONE" => Ok(feature_set::Utf8Validation::None), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -2460,6 +2537,247 @@ impl<'de> serde::Deserialize<'de> for feature_set::StringFieldValidation { deserializer.deserialize_any(GeneratedVisitor) } } +impl serde::Serialize for FeatureSetDefaults { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("google.protobuf.FeatureSetDefaults", len)?; + if true { + struct_ser.serialize_field("defaults", &self.defaults)?; + } + if let Some(v) = self.minimum_edition.as_ref() { + let v = Edition::try_from(*v) + .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("minimumEdition", &v)?; + } + if let Some(v) = self.maximum_edition.as_ref() { + let v = Edition::try_from(*v) + .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("maximumEdition", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for FeatureSetDefaults { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "defaults", + "minimum_edition", + "minimumEdition", + "maximum_edition", + "maximumEdition", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Defaults, + MinimumEdition, + MaximumEdition, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "defaults" => Ok(GeneratedField::Defaults), + "minimumEdition" | "minimum_edition" => Ok(GeneratedField::MinimumEdition), + "maximumEdition" | "maximum_edition" => Ok(GeneratedField::MaximumEdition), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = FeatureSetDefaults; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct google.protobuf.FeatureSetDefaults") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut defaults__ = None; + let mut minimum_edition__ = None; + let mut maximum_edition__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Defaults => { + if defaults__.is_some() { + return Err(serde::de::Error::duplicate_field("defaults")); + } + defaults__ = Some(map_.next_value()?); + } + GeneratedField::MinimumEdition => { + if minimum_edition__.is_some() { + return Err(serde::de::Error::duplicate_field("minimumEdition")); + } + minimum_edition__ = map_.next_value::<::core::option::Option>()?.map(|x| x as i32); + } + GeneratedField::MaximumEdition => { + if maximum_edition__.is_some() { + return Err(serde::de::Error::duplicate_field("maximumEdition")); + } + maximum_edition__ = map_.next_value::<::core::option::Option>()?.map(|x| x as i32); + } + } + } + Ok(FeatureSetDefaults { + defaults: defaults__.unwrap_or_default(), + minimum_edition: minimum_edition__, + maximum_edition: maximum_edition__, + }) + } + } + deserializer.deserialize_struct("google.protobuf.FeatureSetDefaults", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for feature_set_defaults::FeatureSetEditionDefault { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault", len)?; + if let Some(v) = self.edition.as_ref() { + let v = Edition::try_from(*v) + .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("edition", &v)?; + } + if let Some(v) = self.features.as_ref() { + struct_ser.serialize_field("features", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for feature_set_defaults::FeatureSetEditionDefault { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "edition", + "features", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Edition, + Features, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "edition" => Ok(GeneratedField::Edition), + "features" => Ok(GeneratedField::Features), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = feature_set_defaults::FeatureSetEditionDefault; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut edition__ = None; + let mut features__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Edition => { + if edition__.is_some() { + return Err(serde::de::Error::duplicate_field("edition")); + } + edition__ = map_.next_value::<::core::option::Option>()?.map(|x| x as i32); + } + GeneratedField::Features => { + if features__.is_some() { + return Err(serde::de::Error::duplicate_field("features")); + } + features__ = map_.next_value()?; + } + } + } + Ok(feature_set_defaults::FeatureSetEditionDefault { + edition: edition__, + features: features__, + }) + } + } + deserializer.deserialize_struct("google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault", FIELDS, GeneratedVisitor) + } +} impl serde::Serialize for FieldDescriptorProto { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result @@ -2742,8 +3060,8 @@ impl serde::Serialize for field_descriptor_proto::Label { { let variant = match self { Self::Optional => "LABEL_OPTIONAL", - Self::Required => "LABEL_REQUIRED", Self::Repeated => "LABEL_REPEATED", + Self::Required => "LABEL_REQUIRED", }; serializer.serialize_str(variant) } @@ -2756,8 +3074,8 @@ impl<'de> serde::Deserialize<'de> for field_descriptor_proto::Label { { const FIELDS: &[&str] = &[ "LABEL_OPTIONAL", - "LABEL_REQUIRED", "LABEL_REPEATED", + "LABEL_REQUIRED", ]; struct GeneratedVisitor; @@ -2799,8 +3117,8 @@ impl<'de> serde::Deserialize<'de> for field_descriptor_proto::Label { { match value { "LABEL_OPTIONAL" => Ok(field_descriptor_proto::Label::Optional), - "LABEL_REQUIRED" => Ok(field_descriptor_proto::Label::Required), "LABEL_REPEATED" => Ok(field_descriptor_proto::Label::Repeated), + "LABEL_REQUIRED" => Ok(field_descriptor_proto::Label::Required), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -3326,7 +3644,9 @@ impl serde::Serialize for field_options::EditionDefault { } let mut struct_ser = serializer.serialize_struct("google.protobuf.FieldOptions.EditionDefault", len)?; if let Some(v) = self.edition.as_ref() { - struct_ser.serialize_field("edition", v)?; + let v = Edition::try_from(*v) + .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("edition", &v)?; } if let Some(v) = self.value.as_ref() { struct_ser.serialize_field("value", v)?; @@ -3399,7 +3719,7 @@ impl<'de> serde::Deserialize<'de> for field_options::EditionDefault { if edition__.is_some() { return Err(serde::de::Error::duplicate_field("edition")); } - edition__ = map_.next_value()?; + edition__ = map_.next_value::<::core::option::Option>()?.map(|x| x as i32); } GeneratedField::Value => { if value__.is_some() { @@ -3746,7 +4066,9 @@ impl serde::Serialize for FileDescriptorProto { struct_ser.serialize_field("syntax", v)?; } if let Some(v) = self.edition.as_ref() { - struct_ser.serialize_field("edition", v)?; + let v = Edition::try_from(*v) + .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("edition", &v)?; } struct_ser.end() } @@ -3943,7 +4265,7 @@ impl<'de> serde::Deserialize<'de> for FileDescriptorProto { if edition__.is_some() { return Err(serde::de::Error::duplicate_field("edition")); } - edition__ = map_.next_value()?; + edition__ = map_.next_value::<::core::option::Option>()?.map(|x| x as i32); } } } @@ -4129,9 +4451,6 @@ impl serde::Serialize for FileOptions { if true { len += 1; } - if true { - len += 1; - } let mut struct_ser = serializer.serialize_struct("google.protobuf.FileOptions", len)?; if let Some(v) = self.java_package.as_ref() { struct_ser.serialize_field("javaPackage", v)?; @@ -4165,9 +4484,6 @@ impl serde::Serialize for FileOptions { if let Some(v) = self.py_generic_services.as_ref() { struct_ser.serialize_field("pyGenericServices", v)?; } - if let Some(v) = self.php_generic_services.as_ref() { - struct_ser.serialize_field("phpGenericServices", v)?; - } if let Some(v) = self.deprecated.as_ref() { struct_ser.serialize_field("deprecated", v)?; } @@ -4231,8 +4547,6 @@ impl<'de> serde::Deserialize<'de> for FileOptions { "javaGenericServices", "py_generic_services", "pyGenericServices", - "php_generic_services", - "phpGenericServices", "deprecated", "cc_enable_arenas", "ccEnableArenas", @@ -4267,7 +4581,6 @@ impl<'de> serde::Deserialize<'de> for FileOptions { CcGenericServices, JavaGenericServices, PyGenericServices, - PhpGenericServices, Deprecated, CcEnableArenas, ObjcClassPrefix, @@ -4310,7 +4623,6 @@ impl<'de> serde::Deserialize<'de> for FileOptions { "ccGenericServices" | "cc_generic_services" => Ok(GeneratedField::CcGenericServices), "javaGenericServices" | "java_generic_services" => Ok(GeneratedField::JavaGenericServices), "pyGenericServices" | "py_generic_services" => Ok(GeneratedField::PyGenericServices), - "phpGenericServices" | "php_generic_services" => Ok(GeneratedField::PhpGenericServices), "deprecated" => Ok(GeneratedField::Deprecated), "ccEnableArenas" | "cc_enable_arenas" => Ok(GeneratedField::CcEnableArenas), "objcClassPrefix" | "objc_class_prefix" => Ok(GeneratedField::ObjcClassPrefix), @@ -4351,7 +4663,6 @@ impl<'de> serde::Deserialize<'de> for FileOptions { let mut cc_generic_services__ = None; let mut java_generic_services__ = None; let mut py_generic_services__ = None; - let mut php_generic_services__ = None; let mut deprecated__ = None; let mut cc_enable_arenas__ = None; let mut objc_class_prefix__ = None; @@ -4425,12 +4736,6 @@ impl<'de> serde::Deserialize<'de> for FileOptions { } py_generic_services__ = map_.next_value()?; } - GeneratedField::PhpGenericServices => { - if php_generic_services__.is_some() { - return Err(serde::de::Error::duplicate_field("phpGenericServices")); - } - php_generic_services__ = map_.next_value()?; - } GeneratedField::Deprecated => { if deprecated__.is_some() { return Err(serde::de::Error::duplicate_field("deprecated")); @@ -4510,7 +4815,6 @@ impl<'de> serde::Deserialize<'de> for FileOptions { cc_generic_services: cc_generic_services__, java_generic_services: java_generic_services__, py_generic_services: py_generic_services__, - php_generic_services: php_generic_services__, deprecated: deprecated__, cc_enable_arenas: cc_enable_arenas__, objc_class_prefix: objc_class_prefix__, diff --git a/src/prost/proto_descriptor.bin b/src/prost/proto_descriptor.bin index e61b7875b928c81550a504da0286a304dc9021d1..c67990d9aad0072b4e9d1c247c89ad286091abd4 100644 GIT binary patch delta 24162 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 delta 20920 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 Date: Fri, 12 Apr 2024 10:40:29 +0200 Subject: [PATCH 2/3] Patch protos for multi-hop support --- multihop.patch | 137 +++++++ scripts/sync-protobuf.sh | 2 + src/prost/ibc.core.channel.v1.rs | 163 +++++++- src/prost/ibc.core.channel.v1.serde.rs | 521 +++++++++++++++++++++++++ src/prost/ibc.core.client.v1.rs | 131 +++++++ src/prost/ibc.core.client.v1.serde.rs | 226 +++++++++++ src/prost/proto_descriptor.bin | Bin 761618 -> 766151 bytes 7 files changed, 1178 insertions(+), 2 deletions(-) create mode 100644 multihop.patch diff --git a/multihop.patch b/multihop.patch new file mode 100644 index 00000000..52715314 --- /dev/null +++ b/multihop.patch @@ -0,0 +1,137 @@ +diff --git a/proto/ibc/core/channel/v1/channel.proto b/proto/ibc/core/channel/v1/channel.proto +index 44c3240e2..b7596c72b 100644 +--- a/proto/ibc/core/channel/v1/channel.proto ++++ b/proto/ibc/core/channel/v1/channel.proto +@@ -71,10 +71,12 @@ + // A channel has been closed and can no longer be used to send or receive + // packets. + STATE_CLOSED = 4 [(gogoproto.enumvalue_customname) = "CLOSED"]; ++ // A channel has been forced closed due to a frozen client in the connection path. ++ STATE_FROZEN = 5 [(gogoproto.enumvalue_customname) = "FROZEN"]; + // A channel has just accepted the upgrade handshake attempt and is flushing in-flight packets. +- STATE_FLUSHING = 5 [(gogoproto.enumvalue_customname) = "FLUSHING"]; ++ STATE_FLUSHING = 6 [(gogoproto.enumvalue_customname) = "FLUSHING"]; + // A channel has just completed flushing any in-flight packets. +- STATE_FLUSHCOMPLETE = 6 [(gogoproto.enumvalue_customname) = "FLUSHCOMPLETE"]; ++ STATE_FLUSHCOMPLETE = 7 [(gogoproto.enumvalue_customname) = "FLUSHCOMPLETE"]; + } + + // Order defines if a channel is ORDERED or UNORDERED +diff --git a/proto/ibc/core/channel/v1/tx.proto b/proto/ibc/core/channel/v1/tx.proto +index 4b9ad3d75..07ee7f08d 100644 +--- a/proto/ibc/core/channel/v1/tx.proto ++++ b/proto/ibc/core/channel/v1/tx.proto +@@ -9,6 +9,7 @@ + import "ibc/core/client/v1/client.proto"; + import "ibc/core/channel/v1/channel.proto"; + import "ibc/core/channel/v1/upgrade.proto"; ++import "ibc/core/commitment/v1/commitment.proto"; + + // Msg defines the ibc/channel Msg service. + service Msg { +@@ -33,6 +34,9 @@ + // MsgChannelCloseConfirm. + rpc ChannelCloseConfirm(MsgChannelCloseConfirm) returns (MsgChannelCloseConfirmResponse); + ++ // ChannelCloseFrozen defines a rpc handler method for MsgChannelCloseFrozen. ++ rpc ChannelCloseFrozen(MsgChannelCloseFrozen) returns (MsgChannelCloseFrozenResponse); ++ + // RecvPacket defines a rpc handler method for MsgRecvPacket. + rpc RecvPacket(MsgRecvPacket) returns (MsgRecvPacketResponse); + +@@ -208,6 +212,25 @@ + // type. + message MsgChannelCloseConfirmResponse {} + ++// MsgChannelCloseFrozen defines a msg sent by a Relayer to force close ++// a channel due to a frozen client in a multi-hop channel path. ++message MsgChannelCloseFrozen { ++ option (gogoproto.equal) = false; ++ option (gogoproto.goproto_getters) = false; ++ ++ string port_id = 1 [(gogoproto.moretags) = "yaml:\"port_id\""]; ++ string channel_id = 2 [(gogoproto.moretags) = "yaml:\"channel_id\""]; ++ bytes proof_connection = 3 [(gogoproto.moretags) = "yaml:\"proof_connection\""]; ++ bytes proof_client_state = 4 [(gogoproto.moretags) = "yaml:\"proof_client_state\""]; ++ ibc.core.client.v1.Height proof_height = 5 ++ [(gogoproto.moretags) = "yaml:\"proof_height\"", (gogoproto.nullable) = false]; ++ string signer = 6; ++} ++ ++// MsgChannelCloseFrozenResponse defines the Msg/ChannelFrozenConfirm response ++// type. ++message MsgChannelCloseFrozenResponse {} ++ + // MsgRecvPacket receives incoming IBC packet + message MsgRecvPacket { + option (cosmos.msg.v1.signer) = "signer"; +@@ -467,3 +490,23 @@ + // Number of sequences left after pruning. + uint64 total_remaining_sequences = 2; + } ++ ++// MultihopProof holds the information necessary to prove a multihop message ++message MultihopProof { ++ option (gogoproto.equal) = false; ++ option (gogoproto.goproto_getters) = false; ++ ++ bytes proof = 2; ++ bytes value = 3; ++ ibc.core.commitment.v1.MerklePath prefixed_key = 4; ++} ++ ++// MsgMultihopProofs holds the proof information for each intermediary hop for a multihop message ++message MsgMultihopProofs { ++ option (gogoproto.equal) = false; ++ option (gogoproto.goproto_getters) = false; ++ ++ MultihopProof key_proof = 2; ++ repeated MultihopProof connection_proofs = 3; ++ repeated MultihopProof consensus_proofs = 4; ++} +diff --git a/proto/ibc/core/client/v1/query.proto b/proto/ibc/core/client/v1/query.proto +index 0032306ec..4bd66bfee 100644 +--- a/proto/ibc/core/client/v1/query.proto ++++ b/proto/ibc/core/client/v1/query.proto +@@ -36,6 +36,14 @@ service Query { + option (google.api.http).get = "/ibc/core/client/v1/consensus_states/{client_id}"; + } + ++ // NextConsensusStateHeight queries for a consensus state height associated with ++ // a client state at a minimum height greater than a given height. ++ rpc NextConsensusStateHeight(QueryNextConsensusStateHeightRequest) returns (QueryNextConsensusStateHeightResponse) { ++ option (google.api.http).get = "/ibc/core/client/v1/next_height/consensus_states/" ++ "{client_id}/revision/{revision_number}/" ++ "height/{revision_height}"; ++ } ++ + // ConsensusStateHeights queries the height of every consensus states associated with a given client. + rpc ConsensusStateHeights(QueryConsensusStateHeightsRequest) returns (QueryConsensusStateHeightsResponse) { + option (google.api.http).get = "/ibc/core/client/v1/consensus_states/{client_id}/heights"; +@@ -142,6 +150,26 @@ message QueryConsensusStatesResponse { + cosmos.base.query.v1beta1.PageResponse pagination = 2; + } + ++// QueryNextConsensusStateRequest is the request type for the Query/ConsensusState ++// RPC method. Besides the consensus state, it includes a proof and the height ++// from which the proof was retrieved. ++message QueryNextConsensusStateHeightRequest { ++ // client identifier ++ string client_id = 1; ++ // consensus state revision number ++ uint64 revision_number = 2; ++ // consensus state revision height ++ uint64 revision_height = 3; ++} ++ ++// QueryNextConsensusStateResponse is the response type for the Query/ConsensusState ++// RPC method ++message QueryNextConsensusStateHeightResponse { ++ // minimum consensus state height associated with the client identifier larger ++ // than the query height ++ ibc.core.client.v1.Height consensus_height = 1 [(gogoproto.nullable) = false]; ++} ++ + // QueryConsensusStateHeightsRequest is the request type for Query/ConsensusStateHeights + // RPC method. + message QueryConsensusStateHeightsRequest { diff --git a/scripts/sync-protobuf.sh b/scripts/sync-protobuf.sh index dbf5b653..c0b46633 100755 --- a/scripts/sync-protobuf.sh +++ b/scripts/sync-protobuf.sh @@ -170,6 +170,8 @@ cd proto buf export -v -o ../proto-include popd +patch -d "$IBC_GO_DIR/proto-include" -p2 < multihop.patch + NFT_TRANSFER_DIR=$(mktemp -d /tmp/nft-transfer-XXXXXXXX) pushd "$NFT_TRANSFER_DIR" diff --git a/src/prost/ibc.core.channel.v1.rs b/src/prost/ibc.core.channel.v1.rs index 53c79e71..b64c6480 100644 --- a/src/prost/ibc.core.channel.v1.rs +++ b/src/prost/ibc.core.channel.v1.rs @@ -270,10 +270,12 @@ pub enum State { /// A channel has been closed and can no longer be used to send or receive /// packets. Closed = 4, + /// A channel has been forced closed due to a frozen client in the connection path. + Frozen = 5, /// A channel has just accepted the upgrade handshake attempt and is flushing in-flight packets. - Flushing = 5, + Flushing = 6, /// A channel has just completed flushing any in-flight packets. - Flushcomplete = 6, + Flushcomplete = 7, } impl State { /// String value of the enum field names used in the ProtoBuf definition. @@ -287,6 +289,7 @@ impl State { State::Tryopen => "STATE_TRYOPEN", State::Open => "STATE_OPEN", State::Closed => "STATE_CLOSED", + State::Frozen => "STATE_FROZEN", State::Flushing => "STATE_FLUSHING", State::Flushcomplete => "STATE_FLUSHCOMPLETE", } @@ -299,6 +302,7 @@ impl State { "STATE_TRYOPEN" => Some(Self::Tryopen), "STATE_OPEN" => Some(Self::Open), "STATE_CLOSED" => Some(Self::Closed), + "STATE_FROZEN" => Some(Self::Frozen), "STATE_FLUSHING" => Some(Self::Flushing), "STATE_FLUSHCOMPLETE" => Some(Self::Flushcomplete), _ => None, @@ -675,6 +679,43 @@ impl ::prost::Name for MsgChannelCloseConfirmResponse { ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) } } +/// MsgChannelCloseFrozen defines a msg sent by a Relayer to force close +/// a channel due to a frozen client in a multi-hop channel path. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelCloseFrozen { + #[prost(string, tag = "1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(bytes = "vec", tag = "3")] + pub proof_connection: ::prost::alloc::vec::Vec, + #[prost(bytes = "vec", tag = "4")] + pub proof_client_state: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "5")] + pub proof_height: ::core::option::Option, + #[prost(string, tag = "6")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgChannelCloseFrozen { + const NAME: &'static str = "MsgChannelCloseFrozen"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// MsgChannelCloseFrozenResponse defines the Msg/ChannelFrozenConfirm response +/// type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelCloseFrozenResponse {} +impl ::prost::Name for MsgChannelCloseFrozenResponse { + const NAME: &'static str = "MsgChannelCloseFrozenResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// MsgRecvPacket receives incoming IBC packet #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -1167,6 +1208,42 @@ impl ::prost::Name for MsgPruneAcknowledgementsResponse { ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) } } +/// MultihopProof holds the information necessary to prove a multihop message +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MultihopProof { + #[prost(bytes = "vec", tag = "2")] + pub proof: ::prost::alloc::vec::Vec, + #[prost(bytes = "vec", tag = "3")] + pub value: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "4")] + pub prefixed_key: ::core::option::Option, +} +impl ::prost::Name for MultihopProof { + const NAME: &'static str = "MultihopProof"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// MsgMultihopProofs holds the proof information for each intermediary hop for a multihop message +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgMultihopProofs { + #[prost(message, optional, tag = "2")] + pub key_proof: ::core::option::Option, + #[prost(message, repeated, tag = "3")] + pub connection_proofs: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag = "4")] + pub consensus_proofs: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for MsgMultihopProofs { + const NAME: &'static str = "MsgMultihopProofs"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// ResponseResultType defines the possible outcomes of the execution of a message #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] @@ -1452,6 +1529,34 @@ pub mod msg_client { ); self.inner.unary(req, path, codec).await } + /// ChannelCloseFrozen defines a rpc handler method for MsgChannelCloseFrozen. + pub async fn channel_close_frozen( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.core.channel.v1.Msg/ChannelCloseFrozen", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("ibc.core.channel.v1.Msg", "ChannelCloseFrozen"), + ); + self.inner.unary(req, path, codec).await + } /// RecvPacket defines a rpc handler method for MsgRecvPacket. pub async fn recv_packet( &mut self, @@ -1863,6 +1968,14 @@ pub mod msg_server { tonic::Response, tonic::Status, >; + /// ChannelCloseFrozen defines a rpc handler method for MsgChannelCloseFrozen. + async fn channel_close_frozen( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; /// RecvPacket defines a rpc handler method for MsgRecvPacket. async fn recv_packet( &self, @@ -2316,6 +2429,52 @@ pub mod msg_server { }; Box::pin(fut) } + "/ibc.core.channel.v1.Msg/ChannelCloseFrozen" => { + #[allow(non_camel_case_types)] + struct ChannelCloseFrozenSvc(pub Arc); + impl< + T: Msg, + > tonic::server::UnaryService + for ChannelCloseFrozenSvc { + type Response = super::MsgChannelCloseFrozenResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::channel_close_frozen(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ChannelCloseFrozenSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } "/ibc.core.channel.v1.Msg/RecvPacket" => { #[allow(non_camel_case_types)] struct RecvPacketSvc(pub Arc); diff --git a/src/prost/ibc.core.channel.v1.serde.rs b/src/prost/ibc.core.channel.v1.serde.rs index abb6af8a..76453650 100644 --- a/src/prost/ibc.core.channel.v1.serde.rs +++ b/src/prost/ibc.core.channel.v1.serde.rs @@ -1485,6 +1485,264 @@ impl<'de> serde::Deserialize<'de> for MsgChannelCloseConfirmResponse { deserializer.deserialize_struct("ibc.core.channel.v1.MsgChannelCloseConfirmResponse", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for MsgChannelCloseFrozen { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgChannelCloseFrozen", len)?; + if true { + struct_ser.serialize_field("portId", &self.port_id)?; + } + if true { + struct_ser.serialize_field("channelId", &self.channel_id)?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("proofConnection", pbjson::private::base64::encode(&self.proof_connection).as_str())?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("proofClientState", pbjson::private::base64::encode(&self.proof_client_state).as_str())?; + } + if let Some(v) = self.proof_height.as_ref() { + struct_ser.serialize_field("proofHeight", v)?; + } + if true { + struct_ser.serialize_field("signer", &self.signer)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgChannelCloseFrozen { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "port_id", + "portId", + "channel_id", + "channelId", + "proof_connection", + "proofConnection", + "proof_client_state", + "proofClientState", + "proof_height", + "proofHeight", + "signer", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + PortId, + ChannelId, + ProofConnection, + ProofClientState, + ProofHeight, + Signer, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "portId" | "port_id" => Ok(GeneratedField::PortId), + "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), + "proofConnection" | "proof_connection" => Ok(GeneratedField::ProofConnection), + "proofClientState" | "proof_client_state" => Ok(GeneratedField::ProofClientState), + "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight), + "signer" => Ok(GeneratedField::Signer), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgChannelCloseFrozen; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.MsgChannelCloseFrozen") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut port_id__ = None; + let mut channel_id__ = None; + let mut proof_connection__ = None; + let mut proof_client_state__ = None; + let mut proof_height__ = None; + let mut signer__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::PortId => { + if port_id__.is_some() { + return Err(serde::de::Error::duplicate_field("portId")); + } + port_id__ = Some(map_.next_value()?); + } + GeneratedField::ChannelId => { + if channel_id__.is_some() { + return Err(serde::de::Error::duplicate_field("channelId")); + } + channel_id__ = Some(map_.next_value()?); + } + GeneratedField::ProofConnection => { + if proof_connection__.is_some() { + return Err(serde::de::Error::duplicate_field("proofConnection")); + } + proof_connection__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::ProofClientState => { + if proof_client_state__.is_some() { + return Err(serde::de::Error::duplicate_field("proofClientState")); + } + proof_client_state__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::ProofHeight => { + if proof_height__.is_some() { + return Err(serde::de::Error::duplicate_field("proofHeight")); + } + proof_height__ = map_.next_value()?; + } + GeneratedField::Signer => { + if signer__.is_some() { + return Err(serde::de::Error::duplicate_field("signer")); + } + signer__ = Some(map_.next_value()?); + } + } + } + Ok(MsgChannelCloseFrozen { + port_id: port_id__.unwrap_or_default(), + channel_id: channel_id__.unwrap_or_default(), + proof_connection: proof_connection__.unwrap_or_default(), + proof_client_state: proof_client_state__.unwrap_or_default(), + proof_height: proof_height__, + signer: signer__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.MsgChannelCloseFrozen", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MsgChannelCloseFrozenResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgChannelCloseFrozenResponse", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgChannelCloseFrozenResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgChannelCloseFrozenResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.MsgChannelCloseFrozenResponse") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(MsgChannelCloseFrozenResponse { + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.MsgChannelCloseFrozenResponse", FIELDS, GeneratedVisitor) + } +} impl serde::Serialize for MsgChannelCloseInit { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result @@ -4773,6 +5031,134 @@ impl<'de> serde::Deserialize<'de> for MsgChannelUpgradeTryResponse { deserializer.deserialize_struct("ibc.core.channel.v1.MsgChannelUpgradeTryResponse", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for MsgMultihopProofs { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgMultihopProofs", len)?; + if let Some(v) = self.key_proof.as_ref() { + struct_ser.serialize_field("keyProof", v)?; + } + if true { + struct_ser.serialize_field("connectionProofs", &self.connection_proofs)?; + } + if true { + struct_ser.serialize_field("consensusProofs", &self.consensus_proofs)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgMultihopProofs { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "key_proof", + "keyProof", + "connection_proofs", + "connectionProofs", + "consensus_proofs", + "consensusProofs", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + KeyProof, + ConnectionProofs, + ConsensusProofs, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "keyProof" | "key_proof" => Ok(GeneratedField::KeyProof), + "connectionProofs" | "connection_proofs" => Ok(GeneratedField::ConnectionProofs), + "consensusProofs" | "consensus_proofs" => Ok(GeneratedField::ConsensusProofs), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgMultihopProofs; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.MsgMultihopProofs") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut key_proof__ = None; + let mut connection_proofs__ = None; + let mut consensus_proofs__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::KeyProof => { + if key_proof__.is_some() { + return Err(serde::de::Error::duplicate_field("keyProof")); + } + key_proof__ = map_.next_value()?; + } + GeneratedField::ConnectionProofs => { + if connection_proofs__.is_some() { + return Err(serde::de::Error::duplicate_field("connectionProofs")); + } + connection_proofs__ = Some(map_.next_value()?); + } + GeneratedField::ConsensusProofs => { + if consensus_proofs__.is_some() { + return Err(serde::de::Error::duplicate_field("consensusProofs")); + } + consensus_proofs__ = Some(map_.next_value()?); + } + } + } + Ok(MsgMultihopProofs { + key_proof: key_proof__, + connection_proofs: connection_proofs__.unwrap_or_default(), + consensus_proofs: consensus_proofs__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.MsgMultihopProofs", FIELDS, GeneratedVisitor) + } +} impl serde::Serialize for MsgPruneAcknowledgements { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result @@ -6019,6 +6405,138 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateParamsResponse { deserializer.deserialize_struct("ibc.core.channel.v1.MsgUpdateParamsResponse", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for MultihopProof { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MultihopProof", len)?; + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?; + } + if let Some(v) = self.prefixed_key.as_ref() { + struct_ser.serialize_field("prefixedKey", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MultihopProof { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "proof", + "value", + "prefixed_key", + "prefixedKey", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Proof, + Value, + PrefixedKey, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "proof" => Ok(GeneratedField::Proof), + "value" => Ok(GeneratedField::Value), + "prefixedKey" | "prefixed_key" => Ok(GeneratedField::PrefixedKey), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MultihopProof; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.MultihopProof") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut proof__ = None; + let mut value__ = None; + let mut prefixed_key__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Proof => { + if proof__.is_some() { + return Err(serde::de::Error::duplicate_field("proof")); + } + proof__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); + } + value__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::PrefixedKey => { + if prefixed_key__.is_some() { + return Err(serde::de::Error::duplicate_field("prefixedKey")); + } + prefixed_key__ = map_.next_value()?; + } + } + } + Ok(MultihopProof { + proof: proof__.unwrap_or_default(), + value: value__.unwrap_or_default(), + prefixed_key: prefixed_key__, + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.MultihopProof", FIELDS, GeneratedVisitor) + } +} impl serde::Serialize for Order { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result @@ -11056,6 +11574,7 @@ impl serde::Serialize for State { Self::Tryopen => "STATE_TRYOPEN", Self::Open => "STATE_OPEN", Self::Closed => "STATE_CLOSED", + Self::Frozen => "STATE_FROZEN", Self::Flushing => "STATE_FLUSHING", Self::Flushcomplete => "STATE_FLUSHCOMPLETE", }; @@ -11074,6 +11593,7 @@ impl<'de> serde::Deserialize<'de> for State { "STATE_TRYOPEN", "STATE_OPEN", "STATE_CLOSED", + "STATE_FROZEN", "STATE_FLUSHING", "STATE_FLUSHCOMPLETE", ]; @@ -11121,6 +11641,7 @@ impl<'de> serde::Deserialize<'de> for State { "STATE_TRYOPEN" => Ok(State::Tryopen), "STATE_OPEN" => Ok(State::Open), "STATE_CLOSED" => Ok(State::Closed), + "STATE_FROZEN" => Ok(State::Frozen), "STATE_FLUSHING" => Ok(State::Flushing), "STATE_FLUSHCOMPLETE" => Ok(State::Flushcomplete), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), diff --git a/src/prost/ibc.core.client.v1.rs b/src/prost/ibc.core.client.v1.rs index fc33ec80..4297013a 100644 --- a/src/prost/ibc.core.client.v1.rs +++ b/src/prost/ibc.core.client.v1.rs @@ -1442,6 +1442,46 @@ impl ::prost::Name for QueryConsensusStatesResponse { ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) } } +/// QueryNextConsensusStateRequest is the request type for the Query/ConsensusState +/// RPC method. Besides the consensus state, it includes a proof and the height +/// from which the proof was retrieved. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryNextConsensusStateHeightRequest { + /// client identifier + #[prost(string, tag = "1")] + pub client_id: ::prost::alloc::string::String, + /// consensus state revision number + #[prost(uint64, tag = "2")] + pub revision_number: u64, + /// consensus state revision height + #[prost(uint64, tag = "3")] + pub revision_height: u64, +} +impl ::prost::Name for QueryNextConsensusStateHeightRequest { + const NAME: &'static str = "QueryNextConsensusStateHeightRequest"; + const PACKAGE: &'static str = "ibc.core.client.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + } +} +/// QueryNextConsensusStateResponse is the response type for the Query/ConsensusState +/// RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryNextConsensusStateHeightResponse { + /// minimum consensus state height associated with the client identifier larger + /// than the query height + #[prost(message, optional, tag = "1")] + pub consensus_height: ::core::option::Option, +} +impl ::prost::Name for QueryNextConsensusStateHeightResponse { + const NAME: &'static str = "QueryNextConsensusStateHeightResponse"; + const PACKAGE: &'static str = "ibc.core.client.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + } +} /// QueryConsensusStateHeightsRequest is the request type for Query/ConsensusStateHeights /// RPC method. #[allow(clippy::derive_partial_eq_without_eq)] @@ -1796,6 +1836,38 @@ pub mod query_client { .insert(GrpcMethod::new("ibc.core.client.v1.Query", "ConsensusStates")); self.inner.unary(req, path, codec).await } + /// NextConsensusStateHeight queries for a consensus state height associated with + /// a client state at a minimum height greater than a given height. + pub async fn next_consensus_state_height( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.core.client.v1.Query/NextConsensusStateHeight", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "ibc.core.client.v1.Query", + "NextConsensusStateHeight", + ), + ); + self.inner.unary(req, path, codec).await + } /// ConsensusStateHeights queries the height of every consensus states associated with a given client. pub async fn consensus_state_heights( &mut self, @@ -1976,6 +2048,15 @@ pub mod query_server { tonic::Response, tonic::Status, >; + /// NextConsensusStateHeight queries for a consensus state height associated with + /// a client state at a minimum height greater than a given height. + async fn next_consensus_state_height( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; /// ConsensusStateHeights queries the height of every consensus states associated with a given client. async fn consensus_state_heights( &self, @@ -2281,6 +2362,56 @@ pub mod query_server { }; Box::pin(fut) } + "/ibc.core.client.v1.Query/NextConsensusStateHeight" => { + #[allow(non_camel_case_types)] + struct NextConsensusStateHeightSvc(pub Arc); + impl< + T: Query, + > tonic::server::UnaryService< + super::QueryNextConsensusStateHeightRequest, + > for NextConsensusStateHeightSvc { + type Response = super::QueryNextConsensusStateHeightResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + super::QueryNextConsensusStateHeightRequest, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::next_consensus_state_height(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = NextConsensusStateHeightSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } "/ibc.core.client.v1.Query/ConsensusStateHeights" => { #[allow(non_camel_case_types)] struct ConsensusStateHeightsSvc(pub Arc); diff --git a/src/prost/ibc.core.client.v1.serde.rs b/src/prost/ibc.core.client.v1.serde.rs index f3491f56..a0458524 100644 --- a/src/prost/ibc.core.client.v1.serde.rs +++ b/src/prost/ibc.core.client.v1.serde.rs @@ -3996,6 +3996,232 @@ impl<'de> serde::Deserialize<'de> for QueryConsensusStatesResponse { deserializer.deserialize_struct("ibc.core.client.v1.QueryConsensusStatesResponse", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for QueryNextConsensusStateHeightRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.client.v1.QueryNextConsensusStateHeightRequest", len)?; + if true { + struct_ser.serialize_field("clientId", &self.client_id)?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("revisionNumber", ::alloc::string::ToString::to_string(&self.revision_number).as_str())?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("revisionHeight", ::alloc::string::ToString::to_string(&self.revision_height).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryNextConsensusStateHeightRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "client_id", + "clientId", + "revision_number", + "revisionNumber", + "revision_height", + "revisionHeight", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ClientId, + RevisionNumber, + RevisionHeight, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "clientId" | "client_id" => Ok(GeneratedField::ClientId), + "revisionNumber" | "revision_number" => Ok(GeneratedField::RevisionNumber), + "revisionHeight" | "revision_height" => Ok(GeneratedField::RevisionHeight), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryNextConsensusStateHeightRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.client.v1.QueryNextConsensusStateHeightRequest") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut client_id__ = None; + let mut revision_number__ = None; + let mut revision_height__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ClientId => { + if client_id__.is_some() { + return Err(serde::de::Error::duplicate_field("clientId")); + } + client_id__ = Some(map_.next_value()?); + } + GeneratedField::RevisionNumber => { + if revision_number__.is_some() { + return Err(serde::de::Error::duplicate_field("revisionNumber")); + } + revision_number__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::RevisionHeight => { + if revision_height__.is_some() { + return Err(serde::de::Error::duplicate_field("revisionHeight")); + } + revision_height__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(QueryNextConsensusStateHeightRequest { + client_id: client_id__.unwrap_or_default(), + revision_number: revision_number__.unwrap_or_default(), + revision_height: revision_height__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.core.client.v1.QueryNextConsensusStateHeightRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for QueryNextConsensusStateHeightResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.client.v1.QueryNextConsensusStateHeightResponse", len)?; + if let Some(v) = self.consensus_height.as_ref() { + struct_ser.serialize_field("consensusHeight", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryNextConsensusStateHeightResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "consensus_height", + "consensusHeight", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ConsensusHeight, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "consensusHeight" | "consensus_height" => Ok(GeneratedField::ConsensusHeight), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryNextConsensusStateHeightResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.client.v1.QueryNextConsensusStateHeightResponse") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut consensus_height__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ConsensusHeight => { + if consensus_height__.is_some() { + return Err(serde::de::Error::duplicate_field("consensusHeight")); + } + consensus_height__ = map_.next_value()?; + } + } + } + Ok(QueryNextConsensusStateHeightResponse { + consensus_height: consensus_height__, + }) + } + } + deserializer.deserialize_struct("ibc.core.client.v1.QueryNextConsensusStateHeightResponse", FIELDS, GeneratedVisitor) + } +} impl serde::Serialize for QueryUpgradedClientStateRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result diff --git a/src/prost/proto_descriptor.bin b/src/prost/proto_descriptor.bin index c67990d9aad0072b4e9d1c247c89ad286091abd4..f6ef9095c7ee9fd2c66f839ccd71b6790044cf19 100644 GIT binary patch delta 20451 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 Date: Fri, 2 Aug 2024 11:20:53 +0200 Subject: [PATCH 3/3] Regenerate proto derived structs --- src/prost/cosmos.app.v1alpha1.rs | 16 +- src/prost/cosmos.auth.module.v1.rs | 11 +- src/prost/cosmos.auth.v1beta1.rs | 136 ++++-- src/prost/cosmos.bank.module.v1.rs | 6 +- src/prost/cosmos.bank.v1beta1.rs | 206 ++++++-- src/prost/cosmos.base.abci.v1beta1.rs | 51 +- src/prost/cosmos.base.kv.v1beta1.rs | 11 +- src/prost/cosmos.base.node.v1beta1.rs | 11 +- src/prost/cosmos.base.query.v1beta1.rs | 11 +- src/prost/cosmos.base.reflection.v1beta1.rs | 21 +- src/prost/cosmos.base.reflection.v2alpha1.rs | 131 ++++- src/prost/cosmos.base.snapshots.v1beta1.rs | 46 +- src/prost/cosmos.base.tendermint.v1beta1.rs | 106 +++- src/prost/cosmos.base.v1beta1.rs | 21 +- src/prost/cosmos.crypto.ed25519.rs | 11 +- src/prost/cosmos.crypto.hd.v1.rs | 6 +- src/prost/cosmos.crypto.keyring.v1.rs | 26 +- src/prost/cosmos.crypto.multisig.rs | 6 +- src/prost/cosmos.crypto.multisig.v1beta1.rs | 11 +- src/prost/cosmos.crypto.secp256k1.rs | 11 +- src/prost/cosmos.crypto.secp256r1.rs | 11 +- src/prost/cosmos.gov.module.v1.rs | 6 +- src/prost/cosmos.gov.v1.rs | 191 ++++++-- src/prost/cosmos.gov.v1beta1.rs | 171 +++++-- src/prost/cosmos.staking.module.v1.rs | 6 +- src/prost/cosmos.staking.v1beta1.rs | 338 ++++++++++--- src/prost/cosmos.tx.config.v1.rs | 6 +- src/prost/cosmos.tx.signing.v1beta1.rs | 32 +- src/prost/cosmos.tx.v1beta1.rs | 156 ++++-- src/prost/cosmos.upgrade.module.v1.rs | 6 +- src/prost/cosmos.upgrade.v1beta1.rs | 91 +++- src/prost/cosmos_proto.rs | 11 +- src/prost/google.api.rs | 64 +-- src/prost/google.protobuf.rs | 206 +++++--- src/prost/ibc.applications.fee.v1.rs | 196 ++++++-- ...tions.interchain_accounts.controller.v1.rs | 88 ++-- ...ications.interchain_accounts.genesis.v1.rs | 38 +- ...pplications.interchain_accounts.host.v1.rs | 36 +- ...ibc.applications.interchain_accounts.v1.rs | 21 +- src/prost/ibc.applications.nft_transfer.v1.rs | 91 +++- src/prost/ibc.applications.transfer.v1.rs | 106 +++- src/prost/ibc.applications.transfer.v2.rs | 6 +- src/prost/ibc.core.channel.v1.rs | 454 ++++++++++++++---- src/prost/ibc.core.client.v1.rs | 224 +++++++-- src/prost/ibc.core.commitment.v1.rs | 21 +- src/prost/ibc.core.connection.v1.rs | 151 ++++-- src/prost/ibc.core.types.v1.rs | 6 +- src/prost/ibc.lightclients.localhost.v1.rs | 6 +- src/prost/ibc.lightclients.localhost.v2.rs | 6 +- src/prost/ibc.lightclients.solomachine.v2.rs | 81 +++- src/prost/ibc.lightclients.solomachine.v3.rs | 41 +- src/prost/ibc.lightclients.tendermint.v1.rs | 26 +- src/prost/ibc.lightclients.wasm.v1.rs | 81 +++- src/prost/ibc.mock.rs | 21 +- .../interchain_security.ccv.consumer.v1.rs | 55 ++- .../interchain_security.ccv.provider.v1.rs | 276 +++++++++-- src/prost/interchain_security.ccv.v1.rs | 71 ++- src/prost/proto_descriptor.bin | Bin 769543 -> 769491 bytes src/prost/stride.interchainquery.v1.rs | 11 +- 59 files changed, 3343 insertions(+), 920 deletions(-) diff --git a/src/prost/cosmos.app.v1alpha1.rs b/src/prost/cosmos.app.v1alpha1.rs index b70937bf..805d54b1 100644 --- a/src/prost/cosmos.app.v1alpha1.rs +++ b/src/prost/cosmos.app.v1alpha1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// ModuleDescriptor describes an app module. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -27,7 +28,10 @@ impl ::prost::Name for ModuleDescriptor { const NAME: &'static str = "ModuleDescriptor"; const PACKAGE: &'static str = "cosmos.app.v1alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.app.v1alpha1.{}", Self::NAME) + "cosmos.app.v1alpha1.ModuleDescriptor".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.app.v1alpha1.ModuleDescriptor".into() } } /// PackageReference is a reference to a protobuf package used by a module. @@ -79,7 +83,10 @@ impl ::prost::Name for PackageReference { const NAME: &'static str = "PackageReference"; const PACKAGE: &'static str = "cosmos.app.v1alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.app.v1alpha1.{}", Self::NAME) + "cosmos.app.v1alpha1.PackageReference".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.app.v1alpha1.PackageReference".into() } } /// MigrateFromInfo is information on a module version that a newer module @@ -96,6 +103,9 @@ impl ::prost::Name for MigrateFromInfo { const NAME: &'static str = "MigrateFromInfo"; const PACKAGE: &'static str = "cosmos.app.v1alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.app.v1alpha1.{}", Self::NAME) + "cosmos.app.v1alpha1.MigrateFromInfo".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.app.v1alpha1.MigrateFromInfo".into() } } diff --git a/src/prost/cosmos.auth.module.v1.rs b/src/prost/cosmos.auth.module.v1.rs index 59a0940d..bc779d97 100644 --- a/src/prost/cosmos.auth.module.v1.rs +++ b/src/prost/cosmos.auth.module.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// Module is the config object for the auth module. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -16,7 +17,10 @@ impl ::prost::Name for Module { const NAME: &'static str = "Module"; const PACKAGE: &'static str = "cosmos.auth.module.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.module.v1.{}", Self::NAME) + "cosmos.auth.module.v1.Module".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.module.v1.Module".into() } } /// ModuleAccountPermission represents permissions for a module account. @@ -35,6 +39,9 @@ impl ::prost::Name for ModuleAccountPermission { const NAME: &'static str = "ModuleAccountPermission"; const PACKAGE: &'static str = "cosmos.auth.module.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.module.v1.{}", Self::NAME) + "cosmos.auth.module.v1.ModuleAccountPermission".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.module.v1.ModuleAccountPermission".into() } } diff --git a/src/prost/cosmos.auth.v1beta1.rs b/src/prost/cosmos.auth.v1beta1.rs index 6b52b32a..43a40dec 100644 --- a/src/prost/cosmos.auth.v1beta1.rs +++ b/src/prost/cosmos.auth.v1beta1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// BaseAccount defines a base account type. It contains all the necessary fields /// for basic account functionality. Any custom account type should extend this /// type for additional functionality (e.g. vesting). @@ -17,7 +18,10 @@ impl ::prost::Name for BaseAccount { const NAME: &'static str = "BaseAccount"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.BaseAccount".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.BaseAccount".into() } } /// ModuleAccount defines an account for modules that holds coins on a pool. @@ -35,7 +39,10 @@ impl ::prost::Name for ModuleAccount { const NAME: &'static str = "ModuleAccount"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.ModuleAccount".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.ModuleAccount".into() } } /// ModuleCredential represents a unclaimable pubkey for base accounts controlled by modules. @@ -56,7 +63,10 @@ impl ::prost::Name for ModuleCredential { const NAME: &'static str = "ModuleCredential"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.ModuleCredential".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.ModuleCredential".into() } } /// Params defines the parameters for the auth module. @@ -78,7 +88,10 @@ impl ::prost::Name for Params { const NAME: &'static str = "Params"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.Params".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.Params".into() } } /// MsgUpdateParams is the Msg/UpdateParams request type. @@ -100,7 +113,10 @@ impl ::prost::Name for MsgUpdateParams { const NAME: &'static str = "MsgUpdateParams"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.MsgUpdateParams".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.MsgUpdateParams".into() } } /// MsgUpdateParamsResponse defines the response structure for executing a @@ -114,7 +130,10 @@ impl ::prost::Name for MsgUpdateParamsResponse { const NAME: &'static str = "MsgUpdateParamsResponse"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.MsgUpdateParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.MsgUpdateParamsResponse".into() } } /// Generated client implementations. @@ -425,7 +444,10 @@ impl ::prost::Name for QueryAccountsRequest { const NAME: &'static str = "QueryAccountsRequest"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.QueryAccountsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.QueryAccountsRequest".into() } } /// QueryAccountsResponse is the response type for the Query/Accounts RPC method. @@ -447,7 +469,10 @@ impl ::prost::Name for QueryAccountsResponse { const NAME: &'static str = "QueryAccountsResponse"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.QueryAccountsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.QueryAccountsResponse".into() } } /// QueryAccountRequest is the request type for the Query/Account RPC method. @@ -462,7 +487,10 @@ impl ::prost::Name for QueryAccountRequest { const NAME: &'static str = "QueryAccountRequest"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.QueryAccountRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.QueryAccountRequest".into() } } /// QueryAccountResponse is the response type for the Query/Account RPC method. @@ -477,7 +505,10 @@ impl ::prost::Name for QueryAccountResponse { const NAME: &'static str = "QueryAccountResponse"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.QueryAccountResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.QueryAccountResponse".into() } } /// QueryParamsRequest is the request type for the Query/Params RPC method. @@ -488,7 +519,10 @@ impl ::prost::Name for QueryParamsRequest { const NAME: &'static str = "QueryParamsRequest"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.QueryParamsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.QueryParamsRequest".into() } } /// QueryParamsResponse is the response type for the Query/Params RPC method. @@ -503,7 +537,10 @@ impl ::prost::Name for QueryParamsResponse { const NAME: &'static str = "QueryParamsResponse"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.QueryParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.QueryParamsResponse".into() } } /// QueryModuleAccountsRequest is the request type for the Query/ModuleAccounts RPC method. @@ -516,7 +553,10 @@ impl ::prost::Name for QueryModuleAccountsRequest { const NAME: &'static str = "QueryModuleAccountsRequest"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.QueryModuleAccountsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.QueryModuleAccountsRequest".into() } } /// QueryModuleAccountsResponse is the response type for the Query/ModuleAccounts RPC method. @@ -532,7 +572,10 @@ impl ::prost::Name for QueryModuleAccountsResponse { const NAME: &'static str = "QueryModuleAccountsResponse"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.QueryModuleAccountsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.QueryModuleAccountsResponse".into() } } /// QueryModuleAccountByNameRequest is the request type for the Query/ModuleAccountByName RPC method. @@ -546,7 +589,10 @@ impl ::prost::Name for QueryModuleAccountByNameRequest { const NAME: &'static str = "QueryModuleAccountByNameRequest"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.QueryModuleAccountByNameRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.QueryModuleAccountByNameRequest".into() } } /// QueryModuleAccountByNameResponse is the response type for the Query/ModuleAccountByName RPC method. @@ -560,7 +606,10 @@ impl ::prost::Name for QueryModuleAccountByNameResponse { const NAME: &'static str = "QueryModuleAccountByNameResponse"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.QueryModuleAccountByNameResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.QueryModuleAccountByNameResponse".into() } } /// Bech32PrefixRequest is the request type for Bech32Prefix rpc method. @@ -573,7 +622,10 @@ impl ::prost::Name for Bech32PrefixRequest { const NAME: &'static str = "Bech32PrefixRequest"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.Bech32PrefixRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.Bech32PrefixRequest".into() } } /// Bech32PrefixResponse is the response type for Bech32Prefix rpc method. @@ -589,7 +641,10 @@ impl ::prost::Name for Bech32PrefixResponse { const NAME: &'static str = "Bech32PrefixResponse"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.Bech32PrefixResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.Bech32PrefixResponse".into() } } /// AddressBytesToStringRequest is the request type for AddressString rpc method. @@ -605,7 +660,10 @@ impl ::prost::Name for AddressBytesToStringRequest { const NAME: &'static str = "AddressBytesToStringRequest"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.AddressBytesToStringRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.AddressBytesToStringRequest".into() } } /// AddressBytesToStringResponse is the response type for AddressString rpc method. @@ -621,7 +679,10 @@ impl ::prost::Name for AddressBytesToStringResponse { const NAME: &'static str = "AddressBytesToStringResponse"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.AddressBytesToStringResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.AddressBytesToStringResponse".into() } } /// AddressStringToBytesRequest is the request type for AccountBytes rpc method. @@ -637,7 +698,10 @@ impl ::prost::Name for AddressStringToBytesRequest { const NAME: &'static str = "AddressStringToBytesRequest"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.AddressStringToBytesRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.AddressStringToBytesRequest".into() } } /// AddressStringToBytesResponse is the response type for AddressBytes rpc method. @@ -653,7 +717,10 @@ impl ::prost::Name for AddressStringToBytesResponse { const NAME: &'static str = "AddressStringToBytesResponse"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.AddressStringToBytesResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.AddressStringToBytesResponse".into() } } /// QueryAccountAddressByIDRequest is the request type for AccountAddressByID rpc method @@ -680,7 +747,10 @@ impl ::prost::Name for QueryAccountAddressByIdRequest { const NAME: &'static str = "QueryAccountAddressByIDRequest"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.QueryAccountAddressByIDRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.QueryAccountAddressByIDRequest".into() } } /// QueryAccountAddressByIDResponse is the response type for AccountAddressByID rpc method @@ -696,7 +766,10 @@ impl ::prost::Name for QueryAccountAddressByIdResponse { const NAME: &'static str = "QueryAccountAddressByIDResponse"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.QueryAccountAddressByIDResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.QueryAccountAddressByIDResponse".into() } } /// QueryAccountInfoRequest is the Query/AccountInfo request type. @@ -713,7 +786,10 @@ impl ::prost::Name for QueryAccountInfoRequest { const NAME: &'static str = "QueryAccountInfoRequest"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.QueryAccountInfoRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.QueryAccountInfoRequest".into() } } /// QueryAccountInfoResponse is the Query/AccountInfo response type. @@ -730,7 +806,10 @@ impl ::prost::Name for QueryAccountInfoResponse { const NAME: &'static str = "QueryAccountInfoResponse"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.QueryAccountInfoResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.QueryAccountInfoResponse".into() } } /// Generated client implementations. @@ -1791,6 +1870,9 @@ impl ::prost::Name for GenesisState { const NAME: &'static str = "GenesisState"; const PACKAGE: &'static str = "cosmos.auth.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.auth.v1beta1.{}", Self::NAME) + "cosmos.auth.v1beta1.GenesisState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.auth.v1beta1.GenesisState".into() } } diff --git a/src/prost/cosmos.bank.module.v1.rs b/src/prost/cosmos.bank.module.v1.rs index fe1abca4..c955d667 100644 --- a/src/prost/cosmos.bank.module.v1.rs +++ b/src/prost/cosmos.bank.module.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// Module is the config object of the bank module. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -17,6 +18,9 @@ impl ::prost::Name for Module { const NAME: &'static str = "Module"; const PACKAGE: &'static str = "cosmos.bank.module.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.module.v1.{}", Self::NAME) + "cosmos.bank.module.v1.Module".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.module.v1.Module".into() } } diff --git a/src/prost/cosmos.bank.v1beta1.rs b/src/prost/cosmos.bank.v1beta1.rs index 962ff36d..51256193 100644 --- a/src/prost/cosmos.bank.v1beta1.rs +++ b/src/prost/cosmos.bank.v1beta1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// Params defines the parameters for the bank module. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -17,7 +18,10 @@ impl ::prost::Name for Params { const NAME: &'static str = "Params"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.Params".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.Params".into() } } /// SendEnabled maps coin denom to a send_enabled status (whether a denom is @@ -34,7 +38,10 @@ impl ::prost::Name for SendEnabled { const NAME: &'static str = "SendEnabled"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.SendEnabled".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.SendEnabled".into() } } /// Input models transaction input. @@ -50,7 +57,10 @@ impl ::prost::Name for Input { const NAME: &'static str = "Input"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.Input".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.Input".into() } } /// Output models transaction outputs. @@ -66,7 +76,10 @@ impl ::prost::Name for Output { const NAME: &'static str = "Output"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.Output".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.Output".into() } } /// Supply represents a struct that passively keeps track of the total supply @@ -82,7 +95,10 @@ impl ::prost::Name for Supply { const NAME: &'static str = "Supply"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.Supply".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.Supply".into() } } /// DenomUnit represents a struct that describes a given @@ -108,7 +124,10 @@ impl ::prost::Name for DenomUnit { const NAME: &'static str = "DenomUnit"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.DenomUnit".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.DenomUnit".into() } } /// Metadata represents a struct that describes @@ -155,7 +174,10 @@ impl ::prost::Name for Metadata { const NAME: &'static str = "Metadata"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.Metadata".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.Metadata".into() } } /// MsgSend represents a message to send coins from one account to another. @@ -173,7 +195,10 @@ impl ::prost::Name for MsgSend { const NAME: &'static str = "MsgSend"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.MsgSend".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.MsgSend".into() } } /// MsgSendResponse defines the Msg/Send response type. @@ -184,7 +209,10 @@ impl ::prost::Name for MsgSendResponse { const NAME: &'static str = "MsgSendResponse"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.MsgSendResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.MsgSendResponse".into() } } /// MsgMultiSend represents an arbitrary multi-in, multi-out send message. @@ -202,7 +230,10 @@ impl ::prost::Name for MsgMultiSend { const NAME: &'static str = "MsgMultiSend"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.MsgMultiSend".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.MsgMultiSend".into() } } /// MsgMultiSendResponse defines the Msg/MultiSend response type. @@ -213,7 +244,10 @@ impl ::prost::Name for MsgMultiSendResponse { const NAME: &'static str = "MsgMultiSendResponse"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.MsgMultiSendResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.MsgMultiSendResponse".into() } } /// MsgUpdateParams is the Msg/UpdateParams request type. @@ -235,7 +269,10 @@ impl ::prost::Name for MsgUpdateParams { const NAME: &'static str = "MsgUpdateParams"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.MsgUpdateParams".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.MsgUpdateParams".into() } } /// MsgUpdateParamsResponse defines the response structure for executing a @@ -249,7 +286,10 @@ impl ::prost::Name for MsgUpdateParamsResponse { const NAME: &'static str = "MsgUpdateParamsResponse"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.MsgUpdateParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.MsgUpdateParamsResponse".into() } } /// MsgSetSendEnabled is the Msg/SetSendEnabled request type. @@ -278,7 +318,10 @@ impl ::prost::Name for MsgSetSendEnabled { const NAME: &'static str = "MsgSetSendEnabled"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.MsgSetSendEnabled".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.MsgSetSendEnabled".into() } } /// MsgSetSendEnabledResponse defines the Msg/SetSendEnabled response type. @@ -291,7 +334,10 @@ impl ::prost::Name for MsgSetSendEnabledResponse { const NAME: &'static str = "MsgSetSendEnabledResponse"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.MsgSetSendEnabledResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.MsgSetSendEnabledResponse".into() } } /// Generated client implementations. @@ -839,7 +885,10 @@ impl ::prost::Name for QueryBalanceRequest { const NAME: &'static str = "QueryBalanceRequest"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.QueryBalanceRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.QueryBalanceRequest".into() } } /// QueryBalanceResponse is the response type for the Query/Balance RPC method. @@ -854,7 +903,10 @@ impl ::prost::Name for QueryBalanceResponse { const NAME: &'static str = "QueryBalanceResponse"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.QueryBalanceResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.QueryBalanceResponse".into() } } /// QueryBalanceRequest is the request type for the Query/AllBalances RPC method. @@ -874,7 +926,10 @@ impl ::prost::Name for QueryAllBalancesRequest { const NAME: &'static str = "QueryAllBalancesRequest"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.QueryAllBalancesRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.QueryAllBalancesRequest".into() } } /// QueryAllBalancesResponse is the response type for the Query/AllBalances RPC @@ -895,7 +950,10 @@ impl ::prost::Name for QueryAllBalancesResponse { const NAME: &'static str = "QueryAllBalancesResponse"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.QueryAllBalancesResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.QueryAllBalancesResponse".into() } } /// QuerySpendableBalancesRequest defines the gRPC request structure for querying @@ -918,7 +976,10 @@ impl ::prost::Name for QuerySpendableBalancesRequest { const NAME: &'static str = "QuerySpendableBalancesRequest"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.QuerySpendableBalancesRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.QuerySpendableBalancesRequest".into() } } /// QuerySpendableBalancesResponse defines the gRPC response structure for querying @@ -941,7 +1002,10 @@ impl ::prost::Name for QuerySpendableBalancesResponse { const NAME: &'static str = "QuerySpendableBalancesResponse"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.QuerySpendableBalancesResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.QuerySpendableBalancesResponse".into() } } /// QuerySpendableBalanceByDenomRequest defines the gRPC request structure for @@ -962,7 +1026,10 @@ impl ::prost::Name for QuerySpendableBalanceByDenomRequest { const NAME: &'static str = "QuerySpendableBalanceByDenomRequest"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest".into() } } /// QuerySpendableBalanceByDenomResponse defines the gRPC response structure for @@ -980,7 +1047,10 @@ impl ::prost::Name for QuerySpendableBalanceByDenomResponse { const NAME: &'static str = "QuerySpendableBalanceByDenomResponse"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse".into() } } /// QueryTotalSupplyRequest is the request type for the Query/TotalSupply RPC @@ -1000,7 +1070,10 @@ impl ::prost::Name for QueryTotalSupplyRequest { const NAME: &'static str = "QueryTotalSupplyRequest"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.QueryTotalSupplyRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.QueryTotalSupplyRequest".into() } } /// QueryTotalSupplyResponse is the response type for the Query/TotalSupply RPC @@ -1023,7 +1096,10 @@ impl ::prost::Name for QueryTotalSupplyResponse { const NAME: &'static str = "QueryTotalSupplyResponse"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.QueryTotalSupplyResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.QueryTotalSupplyResponse".into() } } /// QuerySupplyOfRequest is the request type for the Query/SupplyOf RPC method. @@ -1038,7 +1114,10 @@ impl ::prost::Name for QuerySupplyOfRequest { const NAME: &'static str = "QuerySupplyOfRequest"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.QuerySupplyOfRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.QuerySupplyOfRequest".into() } } /// QuerySupplyOfResponse is the response type for the Query/SupplyOf RPC method. @@ -1053,7 +1132,10 @@ impl ::prost::Name for QuerySupplyOfResponse { const NAME: &'static str = "QuerySupplyOfResponse"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.QuerySupplyOfResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.QuerySupplyOfResponse".into() } } /// QueryParamsRequest defines the request type for querying x/bank parameters. @@ -1064,7 +1146,10 @@ impl ::prost::Name for QueryParamsRequest { const NAME: &'static str = "QueryParamsRequest"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.QueryParamsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.QueryParamsRequest".into() } } /// QueryParamsResponse defines the response type for querying x/bank parameters. @@ -1078,7 +1163,10 @@ impl ::prost::Name for QueryParamsResponse { const NAME: &'static str = "QueryParamsResponse"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.QueryParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.QueryParamsResponse".into() } } /// QueryDenomsMetadataRequest is the request type for the Query/DenomsMetadata RPC method. @@ -1095,7 +1183,10 @@ impl ::prost::Name for QueryDenomsMetadataRequest { const NAME: &'static str = "QueryDenomsMetadataRequest"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.QueryDenomsMetadataRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.QueryDenomsMetadataRequest".into() } } /// QueryDenomsMetadataResponse is the response type for the Query/DenomsMetadata RPC @@ -1116,7 +1207,10 @@ impl ::prost::Name for QueryDenomsMetadataResponse { const NAME: &'static str = "QueryDenomsMetadataResponse"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.QueryDenomsMetadataResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.QueryDenomsMetadataResponse".into() } } /// QueryDenomMetadataRequest is the request type for the Query/DenomMetadata RPC method. @@ -1131,7 +1225,10 @@ impl ::prost::Name for QueryDenomMetadataRequest { const NAME: &'static str = "QueryDenomMetadataRequest"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.QueryDenomMetadataRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.QueryDenomMetadataRequest".into() } } /// QueryDenomMetadataResponse is the response type for the Query/DenomMetadata RPC @@ -1147,7 +1244,10 @@ impl ::prost::Name for QueryDenomMetadataResponse { const NAME: &'static str = "QueryDenomMetadataResponse"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.QueryDenomMetadataResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.QueryDenomMetadataResponse".into() } } /// QueryDenomOwnersRequest defines the request type for the DenomOwners RPC query, @@ -1169,7 +1269,10 @@ impl ::prost::Name for QueryDenomOwnersRequest { const NAME: &'static str = "QueryDenomOwnersRequest"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.QueryDenomOwnersRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.QueryDenomOwnersRequest".into() } } /// DenomOwner defines structure representing an account that owns or holds a @@ -1191,7 +1294,10 @@ impl ::prost::Name for DenomOwner { const NAME: &'static str = "DenomOwner"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.DenomOwner".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.DenomOwner".into() } } /// QueryDenomOwnersResponse defines the RPC response of a DenomOwners RPC query. @@ -1212,7 +1318,10 @@ impl ::prost::Name for QueryDenomOwnersResponse { const NAME: &'static str = "QueryDenomOwnersResponse"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.QueryDenomOwnersResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.QueryDenomOwnersResponse".into() } } /// QuerySendEnabledRequest defines the RPC request for looking up SendEnabled entries. @@ -1235,7 +1344,10 @@ impl ::prost::Name for QuerySendEnabledRequest { const NAME: &'static str = "QuerySendEnabledRequest"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.QuerySendEnabledRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.QuerySendEnabledRequest".into() } } /// QuerySendEnabledResponse defines the RPC response of a SendEnable query. @@ -1257,7 +1369,10 @@ impl ::prost::Name for QuerySendEnabledResponse { const NAME: &'static str = "QuerySendEnabledResponse"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.QuerySendEnabledResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.QuerySendEnabledResponse".into() } } /// Generated client implementations. @@ -2435,7 +2550,10 @@ impl ::prost::Name for SendAuthorization { const NAME: &'static str = "SendAuthorization"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.SendAuthorization".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.SendAuthorization".into() } } /// GenesisState defines the bank module's genesis state. @@ -2465,7 +2583,10 @@ impl ::prost::Name for GenesisState { const NAME: &'static str = "GenesisState"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.GenesisState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.GenesisState".into() } } /// Balance defines an account address and balance pair used in the bank module's @@ -2484,6 +2605,9 @@ impl ::prost::Name for Balance { const NAME: &'static str = "Balance"; const PACKAGE: &'static str = "cosmos.bank.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.bank.v1beta1.{}", Self::NAME) + "cosmos.bank.v1beta1.Balance".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.bank.v1beta1.Balance".into() } } diff --git a/src/prost/cosmos.base.abci.v1beta1.rs b/src/prost/cosmos.base.abci.v1beta1.rs index 4602756d..6a9a1b96 100644 --- a/src/prost/cosmos.base.abci.v1beta1.rs +++ b/src/prost/cosmos.base.abci.v1beta1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// TxResponse defines a structure containing relevant tx data and metadata. The /// tags are stringified and the log is JSON decoded. #[allow(clippy::derive_partial_eq_without_eq)] @@ -55,7 +56,10 @@ impl ::prost::Name for TxResponse { const NAME: &'static str = "TxResponse"; const PACKAGE: &'static str = "cosmos.base.abci.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.abci.v1beta1.{}", Self::NAME) + "cosmos.base.abci.v1beta1.TxResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.abci.v1beta1.TxResponse".into() } } /// ABCIMessageLog defines a structure containing an indexed tx ABCI message log. @@ -75,7 +79,10 @@ impl ::prost::Name for AbciMessageLog { const NAME: &'static str = "ABCIMessageLog"; const PACKAGE: &'static str = "cosmos.base.abci.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.abci.v1beta1.{}", Self::NAME) + "cosmos.base.abci.v1beta1.ABCIMessageLog".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.abci.v1beta1.ABCIMessageLog".into() } } /// StringEvent defines en Event object wrapper where all the attributes @@ -92,7 +99,10 @@ impl ::prost::Name for StringEvent { const NAME: &'static str = "StringEvent"; const PACKAGE: &'static str = "cosmos.base.abci.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.abci.v1beta1.{}", Self::NAME) + "cosmos.base.abci.v1beta1.StringEvent".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.abci.v1beta1.StringEvent".into() } } /// Attribute defines an attribute wrapper where the key and value are @@ -109,7 +119,10 @@ impl ::prost::Name for Attribute { const NAME: &'static str = "Attribute"; const PACKAGE: &'static str = "cosmos.base.abci.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.abci.v1beta1.{}", Self::NAME) + "cosmos.base.abci.v1beta1.Attribute".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.abci.v1beta1.Attribute".into() } } /// GasInfo defines tx execution gas context. @@ -127,7 +140,10 @@ impl ::prost::Name for GasInfo { const NAME: &'static str = "GasInfo"; const PACKAGE: &'static str = "cosmos.base.abci.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.abci.v1beta1.{}", Self::NAME) + "cosmos.base.abci.v1beta1.GasInfo".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.abci.v1beta1.GasInfo".into() } } /// Result is the union of ResponseFormat and ResponseCheckTx. @@ -160,7 +176,10 @@ impl ::prost::Name for Result { const NAME: &'static str = "Result"; const PACKAGE: &'static str = "cosmos.base.abci.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.abci.v1beta1.{}", Self::NAME) + "cosmos.base.abci.v1beta1.Result".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.abci.v1beta1.Result".into() } } /// SimulationResponse defines the response generated when a transaction is @@ -177,7 +196,10 @@ impl ::prost::Name for SimulationResponse { const NAME: &'static str = "SimulationResponse"; const PACKAGE: &'static str = "cosmos.base.abci.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.abci.v1beta1.{}", Self::NAME) + "cosmos.base.abci.v1beta1.SimulationResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.abci.v1beta1.SimulationResponse".into() } } /// MsgData defines the data returned in a Result object during message @@ -194,7 +216,10 @@ impl ::prost::Name for MsgData { const NAME: &'static str = "MsgData"; const PACKAGE: &'static str = "cosmos.base.abci.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.abci.v1beta1.{}", Self::NAME) + "cosmos.base.abci.v1beta1.MsgData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.abci.v1beta1.MsgData".into() } } /// TxMsgData defines a list of MsgData. A transaction will have a MsgData object @@ -218,7 +243,10 @@ impl ::prost::Name for TxMsgData { const NAME: &'static str = "TxMsgData"; const PACKAGE: &'static str = "cosmos.base.abci.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.abci.v1beta1.{}", Self::NAME) + "cosmos.base.abci.v1beta1.TxMsgData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.abci.v1beta1.TxMsgData".into() } } /// SearchTxsResult defines a structure for querying txs pageable @@ -248,6 +276,9 @@ impl ::prost::Name for SearchTxsResult { const NAME: &'static str = "SearchTxsResult"; const PACKAGE: &'static str = "cosmos.base.abci.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.abci.v1beta1.{}", Self::NAME) + "cosmos.base.abci.v1beta1.SearchTxsResult".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.abci.v1beta1.SearchTxsResult".into() } } diff --git a/src/prost/cosmos.base.kv.v1beta1.rs b/src/prost/cosmos.base.kv.v1beta1.rs index 6bd5f9c6..b0ee7493 100644 --- a/src/prost/cosmos.base.kv.v1beta1.rs +++ b/src/prost/cosmos.base.kv.v1beta1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// Pairs defines a repeated slice of Pair objects. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -9,7 +10,10 @@ impl ::prost::Name for Pairs { const NAME: &'static str = "Pairs"; const PACKAGE: &'static str = "cosmos.base.kv.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.kv.v1beta1.{}", Self::NAME) + "cosmos.base.kv.v1beta1.Pairs".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.kv.v1beta1.Pairs".into() } } /// Pair defines a key/value bytes tuple. @@ -25,6 +29,9 @@ impl ::prost::Name for Pair { const NAME: &'static str = "Pair"; const PACKAGE: &'static str = "cosmos.base.kv.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.kv.v1beta1.{}", Self::NAME) + "cosmos.base.kv.v1beta1.Pair".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.kv.v1beta1.Pair".into() } } diff --git a/src/prost/cosmos.base.node.v1beta1.rs b/src/prost/cosmos.base.node.v1beta1.rs index 28e614e5..c67ca56b 100644 --- a/src/prost/cosmos.base.node.v1beta1.rs +++ b/src/prost/cosmos.base.node.v1beta1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// ConfigRequest defines the request structure for the Config gRPC query. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, Copy, PartialEq, ::prost::Message)] @@ -6,7 +7,10 @@ impl ::prost::Name for ConfigRequest { const NAME: &'static str = "ConfigRequest"; const PACKAGE: &'static str = "cosmos.base.node.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.node.v1beta1.{}", Self::NAME) + "cosmos.base.node.v1beta1.ConfigRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.node.v1beta1.ConfigRequest".into() } } /// ConfigResponse defines the response structure for the Config gRPC query. @@ -20,7 +24,10 @@ impl ::prost::Name for ConfigResponse { const NAME: &'static str = "ConfigResponse"; const PACKAGE: &'static str = "cosmos.base.node.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.node.v1beta1.{}", Self::NAME) + "cosmos.base.node.v1beta1.ConfigResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.node.v1beta1.ConfigResponse".into() } } /// Generated client implementations. diff --git a/src/prost/cosmos.base.query.v1beta1.rs b/src/prost/cosmos.base.query.v1beta1.rs index 2a5124cf..dc11f529 100644 --- a/src/prost/cosmos.base.query.v1beta1.rs +++ b/src/prost/cosmos.base.query.v1beta1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// PageRequest is to be embedded in gRPC request messages for efficient /// pagination. Ex: /// @@ -38,7 +39,10 @@ impl ::prost::Name for PageRequest { const NAME: &'static str = "PageRequest"; const PACKAGE: &'static str = "cosmos.base.query.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.query.v1beta1.{}", Self::NAME) + "cosmos.base.query.v1beta1.PageRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.query.v1beta1.PageRequest".into() } } /// PageResponse is to be embedded in gRPC response messages where the @@ -65,6 +69,9 @@ impl ::prost::Name for PageResponse { const NAME: &'static str = "PageResponse"; const PACKAGE: &'static str = "cosmos.base.query.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.query.v1beta1.{}", Self::NAME) + "cosmos.base.query.v1beta1.PageResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.query.v1beta1.PageResponse".into() } } diff --git a/src/prost/cosmos.base.reflection.v1beta1.rs b/src/prost/cosmos.base.reflection.v1beta1.rs index b1b9284b..27eaacf3 100644 --- a/src/prost/cosmos.base.reflection.v1beta1.rs +++ b/src/prost/cosmos.base.reflection.v1beta1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// ListAllInterfacesRequest is the request type of the ListAllInterfaces RPC. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, Copy, PartialEq, ::prost::Message)] @@ -6,7 +7,10 @@ impl ::prost::Name for ListAllInterfacesRequest { const NAME: &'static str = "ListAllInterfacesRequest"; const PACKAGE: &'static str = "cosmos.base.reflection.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v1beta1.{}", Self::NAME) + "cosmos.base.reflection.v1beta1.ListAllInterfacesRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v1beta1.ListAllInterfacesRequest".into() } } /// ListAllInterfacesResponse is the response type of the ListAllInterfaces RPC. @@ -21,7 +25,10 @@ impl ::prost::Name for ListAllInterfacesResponse { const NAME: &'static str = "ListAllInterfacesResponse"; const PACKAGE: &'static str = "cosmos.base.reflection.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v1beta1.{}", Self::NAME) + "cosmos.base.reflection.v1beta1.ListAllInterfacesResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v1beta1.ListAllInterfacesResponse".into() } } /// ListImplementationsRequest is the request type of the ListImplementations @@ -37,7 +44,10 @@ impl ::prost::Name for ListImplementationsRequest { const NAME: &'static str = "ListImplementationsRequest"; const PACKAGE: &'static str = "cosmos.base.reflection.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v1beta1.{}", Self::NAME) + "cosmos.base.reflection.v1beta1.ListImplementationsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v1beta1.ListImplementationsRequest".into() } } /// ListImplementationsResponse is the response type of the ListImplementations @@ -54,7 +64,10 @@ impl ::prost::Name for ListImplementationsResponse { const NAME: &'static str = "ListImplementationsResponse"; const PACKAGE: &'static str = "cosmos.base.reflection.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v1beta1.{}", Self::NAME) + "cosmos.base.reflection.v1beta1.ListImplementationsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v1beta1.ListImplementationsResponse".into() } } /// Generated client implementations. diff --git a/src/prost/cosmos.base.reflection.v2alpha1.rs b/src/prost/cosmos.base.reflection.v2alpha1.rs index 56f53a87..59253201 100644 --- a/src/prost/cosmos.base.reflection.v2alpha1.rs +++ b/src/prost/cosmos.base.reflection.v2alpha1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// AppDescriptor describes a cosmos-sdk based application #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -26,7 +27,10 @@ impl ::prost::Name for AppDescriptor { const NAME: &'static str = "AppDescriptor"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.AppDescriptor".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.AppDescriptor".into() } } /// TxDescriptor describes the accepted transaction type @@ -46,7 +50,10 @@ impl ::prost::Name for TxDescriptor { const NAME: &'static str = "TxDescriptor"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.TxDescriptor".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.TxDescriptor".into() } } /// AuthnDescriptor provides information on how to sign transactions without relying @@ -62,7 +69,10 @@ impl ::prost::Name for AuthnDescriptor { const NAME: &'static str = "AuthnDescriptor"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.AuthnDescriptor".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.AuthnDescriptor".into() } } /// SigningModeDescriptor provides information on a signing flow of the application @@ -87,7 +97,10 @@ impl ::prost::Name for SigningModeDescriptor { const NAME: &'static str = "SigningModeDescriptor"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.SigningModeDescriptor".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.SigningModeDescriptor".into() } } /// ChainDescriptor describes chain information of the application @@ -102,7 +115,10 @@ impl ::prost::Name for ChainDescriptor { const NAME: &'static str = "ChainDescriptor"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.ChainDescriptor".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.ChainDescriptor".into() } } /// CodecDescriptor describes the registered interfaces and provides metadata information on the types @@ -117,7 +133,10 @@ impl ::prost::Name for CodecDescriptor { const NAME: &'static str = "CodecDescriptor"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.CodecDescriptor".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.CodecDescriptor".into() } } /// InterfaceDescriptor describes the implementation of an interface @@ -141,7 +160,10 @@ impl ::prost::Name for InterfaceDescriptor { const NAME: &'static str = "InterfaceDescriptor"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.InterfaceDescriptor".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.InterfaceDescriptor".into() } } /// InterfaceImplementerDescriptor describes an interface implementer @@ -162,7 +184,10 @@ impl ::prost::Name for InterfaceImplementerDescriptor { const NAME: &'static str = "InterfaceImplementerDescriptor"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.InterfaceImplementerDescriptor".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.InterfaceImplementerDescriptor".into() } } /// InterfaceAcceptingMessageDescriptor describes a protobuf message which contains @@ -183,7 +208,10 @@ impl ::prost::Name for InterfaceAcceptingMessageDescriptor { const NAME: &'static str = "InterfaceAcceptingMessageDescriptor"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.InterfaceAcceptingMessageDescriptor".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.InterfaceAcceptingMessageDescriptor".into() } } /// ConfigurationDescriptor contains metadata information on the sdk.Config @@ -198,7 +226,10 @@ impl ::prost::Name for ConfigurationDescriptor { const NAME: &'static str = "ConfigurationDescriptor"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.ConfigurationDescriptor".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.ConfigurationDescriptor".into() } } /// MsgDescriptor describes a cosmos-sdk message that can be delivered with a transaction @@ -213,7 +244,10 @@ impl ::prost::Name for MsgDescriptor { const NAME: &'static str = "MsgDescriptor"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.MsgDescriptor".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.MsgDescriptor".into() } } /// GetAuthnDescriptorRequest is the request used for the GetAuthnDescriptor RPC @@ -224,7 +258,10 @@ impl ::prost::Name for GetAuthnDescriptorRequest { const NAME: &'static str = "GetAuthnDescriptorRequest"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.GetAuthnDescriptorRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.GetAuthnDescriptorRequest".into() } } /// GetAuthnDescriptorResponse is the response returned by the GetAuthnDescriptor RPC @@ -239,7 +276,10 @@ impl ::prost::Name for GetAuthnDescriptorResponse { const NAME: &'static str = "GetAuthnDescriptorResponse"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.GetAuthnDescriptorResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.GetAuthnDescriptorResponse".into() } } /// GetChainDescriptorRequest is the request used for the GetChainDescriptor RPC @@ -250,7 +290,10 @@ impl ::prost::Name for GetChainDescriptorRequest { const NAME: &'static str = "GetChainDescriptorRequest"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.GetChainDescriptorRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.GetChainDescriptorRequest".into() } } /// GetChainDescriptorResponse is the response returned by the GetChainDescriptor RPC @@ -265,7 +308,10 @@ impl ::prost::Name for GetChainDescriptorResponse { const NAME: &'static str = "GetChainDescriptorResponse"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.GetChainDescriptorResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.GetChainDescriptorResponse".into() } } /// GetCodecDescriptorRequest is the request used for the GetCodecDescriptor RPC @@ -276,7 +322,10 @@ impl ::prost::Name for GetCodecDescriptorRequest { const NAME: &'static str = "GetCodecDescriptorRequest"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.GetCodecDescriptorRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.GetCodecDescriptorRequest".into() } } /// GetCodecDescriptorResponse is the response returned by the GetCodecDescriptor RPC @@ -291,7 +340,10 @@ impl ::prost::Name for GetCodecDescriptorResponse { const NAME: &'static str = "GetCodecDescriptorResponse"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.GetCodecDescriptorResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.GetCodecDescriptorResponse".into() } } /// GetConfigurationDescriptorRequest is the request used for the GetConfigurationDescriptor RPC @@ -302,7 +354,10 @@ impl ::prost::Name for GetConfigurationDescriptorRequest { const NAME: &'static str = "GetConfigurationDescriptorRequest"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.GetConfigurationDescriptorRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.GetConfigurationDescriptorRequest".into() } } /// GetConfigurationDescriptorResponse is the response returned by the GetConfigurationDescriptor RPC @@ -317,7 +372,10 @@ impl ::prost::Name for GetConfigurationDescriptorResponse { const NAME: &'static str = "GetConfigurationDescriptorResponse"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.GetConfigurationDescriptorResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.GetConfigurationDescriptorResponse".into() } } /// GetQueryServicesDescriptorRequest is the request used for the GetQueryServicesDescriptor RPC @@ -328,7 +386,10 @@ impl ::prost::Name for GetQueryServicesDescriptorRequest { const NAME: &'static str = "GetQueryServicesDescriptorRequest"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.GetQueryServicesDescriptorRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.GetQueryServicesDescriptorRequest".into() } } /// GetQueryServicesDescriptorResponse is the response returned by the GetQueryServicesDescriptor RPC @@ -343,7 +404,10 @@ impl ::prost::Name for GetQueryServicesDescriptorResponse { const NAME: &'static str = "GetQueryServicesDescriptorResponse"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.GetQueryServicesDescriptorResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.GetQueryServicesDescriptorResponse".into() } } /// GetTxDescriptorRequest is the request used for the GetTxDescriptor RPC @@ -354,7 +418,10 @@ impl ::prost::Name for GetTxDescriptorRequest { const NAME: &'static str = "GetTxDescriptorRequest"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.GetTxDescriptorRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.GetTxDescriptorRequest".into() } } /// GetTxDescriptorResponse is the response returned by the GetTxDescriptor RPC @@ -370,7 +437,10 @@ impl ::prost::Name for GetTxDescriptorResponse { const NAME: &'static str = "GetTxDescriptorResponse"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.GetTxDescriptorResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.GetTxDescriptorResponse".into() } } /// QueryServicesDescriptor contains the list of cosmos-sdk queriable services @@ -385,7 +455,10 @@ impl ::prost::Name for QueryServicesDescriptor { const NAME: &'static str = "QueryServicesDescriptor"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.QueryServicesDescriptor".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.QueryServicesDescriptor".into() } } /// QueryServiceDescriptor describes a cosmos-sdk queryable service @@ -406,7 +479,10 @@ impl ::prost::Name for QueryServiceDescriptor { const NAME: &'static str = "QueryServiceDescriptor"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.QueryServiceDescriptor".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.QueryServiceDescriptor".into() } } /// QueryMethodDescriptor describes a queryable method of a query service @@ -427,7 +503,10 @@ impl ::prost::Name for QueryMethodDescriptor { const NAME: &'static str = "QueryMethodDescriptor"; const PACKAGE: &'static str = "cosmos.base.reflection.v2alpha1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.reflection.v2alpha1.{}", Self::NAME) + "cosmos.base.reflection.v2alpha1.QueryMethodDescriptor".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.reflection.v2alpha1.QueryMethodDescriptor".into() } } /// Generated client implementations. diff --git a/src/prost/cosmos.base.snapshots.v1beta1.rs b/src/prost/cosmos.base.snapshots.v1beta1.rs index 614c936c..5dffaf63 100644 --- a/src/prost/cosmos.base.snapshots.v1beta1.rs +++ b/src/prost/cosmos.base.snapshots.v1beta1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// Snapshot contains Tendermint state sync snapshot info. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -17,7 +18,10 @@ impl ::prost::Name for Snapshot { const NAME: &'static str = "Snapshot"; const PACKAGE: &'static str = "cosmos.base.snapshots.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.snapshots.v1beta1.{}", Self::NAME) + "cosmos.base.snapshots.v1beta1.Snapshot".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.snapshots.v1beta1.Snapshot".into() } } /// Metadata contains SDK-specific snapshot metadata. @@ -32,7 +36,10 @@ impl ::prost::Name for Metadata { const NAME: &'static str = "Metadata"; const PACKAGE: &'static str = "cosmos.base.snapshots.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.snapshots.v1beta1.{}", Self::NAME) + "cosmos.base.snapshots.v1beta1.Metadata".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.snapshots.v1beta1.Metadata".into() } } /// SnapshotItem is an item contained in a rootmulti.Store snapshot. @@ -69,7 +76,10 @@ impl ::prost::Name for SnapshotItem { const NAME: &'static str = "SnapshotItem"; const PACKAGE: &'static str = "cosmos.base.snapshots.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.snapshots.v1beta1.{}", Self::NAME) + "cosmos.base.snapshots.v1beta1.SnapshotItem".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.snapshots.v1beta1.SnapshotItem".into() } } /// SnapshotStoreItem contains metadata about a snapshotted store. @@ -85,7 +95,10 @@ impl ::prost::Name for SnapshotStoreItem { const NAME: &'static str = "SnapshotStoreItem"; const PACKAGE: &'static str = "cosmos.base.snapshots.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.snapshots.v1beta1.{}", Self::NAME) + "cosmos.base.snapshots.v1beta1.SnapshotStoreItem".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.snapshots.v1beta1.SnapshotStoreItem".into() } } /// SnapshotIAVLItem is an exported IAVL node. @@ -109,7 +122,10 @@ impl ::prost::Name for SnapshotIavlItem { const NAME: &'static str = "SnapshotIAVLItem"; const PACKAGE: &'static str = "cosmos.base.snapshots.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.snapshots.v1beta1.{}", Self::NAME) + "cosmos.base.snapshots.v1beta1.SnapshotIAVLItem".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.snapshots.v1beta1.SnapshotIAVLItem".into() } } /// SnapshotExtensionMeta contains metadata about an external snapshotter. @@ -127,7 +143,10 @@ impl ::prost::Name for SnapshotExtensionMeta { const NAME: &'static str = "SnapshotExtensionMeta"; const PACKAGE: &'static str = "cosmos.base.snapshots.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.snapshots.v1beta1.{}", Self::NAME) + "cosmos.base.snapshots.v1beta1.SnapshotExtensionMeta".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.snapshots.v1beta1.SnapshotExtensionMeta".into() } } /// SnapshotExtensionPayload contains payloads of an external snapshotter. @@ -143,7 +162,10 @@ impl ::prost::Name for SnapshotExtensionPayload { const NAME: &'static str = "SnapshotExtensionPayload"; const PACKAGE: &'static str = "cosmos.base.snapshots.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.snapshots.v1beta1.{}", Self::NAME) + "cosmos.base.snapshots.v1beta1.SnapshotExtensionPayload".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.snapshots.v1beta1.SnapshotExtensionPayload".into() } } /// SnapshotKVItem is an exported Key/Value Pair @@ -162,7 +184,10 @@ impl ::prost::Name for SnapshotKvItem { const NAME: &'static str = "SnapshotKVItem"; const PACKAGE: &'static str = "cosmos.base.snapshots.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.snapshots.v1beta1.{}", Self::NAME) + "cosmos.base.snapshots.v1beta1.SnapshotKVItem".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.snapshots.v1beta1.SnapshotKVItem".into() } } /// SnapshotSchema is an exported schema of smt store @@ -179,6 +204,9 @@ impl ::prost::Name for SnapshotSchema { const NAME: &'static str = "SnapshotSchema"; const PACKAGE: &'static str = "cosmos.base.snapshots.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.snapshots.v1beta1.{}", Self::NAME) + "cosmos.base.snapshots.v1beta1.SnapshotSchema".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.snapshots.v1beta1.SnapshotSchema".into() } } diff --git a/src/prost/cosmos.base.tendermint.v1beta1.rs b/src/prost/cosmos.base.tendermint.v1beta1.rs index bcb8755f..5c4bee50 100644 --- a/src/prost/cosmos.base.tendermint.v1beta1.rs +++ b/src/prost/cosmos.base.tendermint.v1beta1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// Block is tendermint type Block, with the Header proposer address /// field converted to bech32 string. #[allow(clippy::derive_partial_eq_without_eq)] @@ -16,7 +17,10 @@ impl ::prost::Name for Block { const NAME: &'static str = "Block"; const PACKAGE: &'static str = "cosmos.base.tendermint.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.tendermint.v1beta1.{}", Self::NAME) + "cosmos.base.tendermint.v1beta1.Block".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.tendermint.v1beta1.Block".into() } } /// Header defines the structure of a Tendermint block header. @@ -79,7 +83,10 @@ impl ::prost::Name for Header { const NAME: &'static str = "Header"; const PACKAGE: &'static str = "cosmos.base.tendermint.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.tendermint.v1beta1.{}", Self::NAME) + "cosmos.base.tendermint.v1beta1.Header".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.tendermint.v1beta1.Header".into() } } /// GetValidatorSetByHeightRequest is the request type for the Query/GetValidatorSetByHeight RPC method. @@ -96,7 +103,10 @@ impl ::prost::Name for GetValidatorSetByHeightRequest { const NAME: &'static str = "GetValidatorSetByHeightRequest"; const PACKAGE: &'static str = "cosmos.base.tendermint.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.tendermint.v1beta1.{}", Self::NAME) + "cosmos.base.tendermint.v1beta1.GetValidatorSetByHeightRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.tendermint.v1beta1.GetValidatorSetByHeightRequest".into() } } /// GetValidatorSetByHeightResponse is the response type for the Query/GetValidatorSetByHeight RPC method. @@ -115,7 +125,10 @@ impl ::prost::Name for GetValidatorSetByHeightResponse { const NAME: &'static str = "GetValidatorSetByHeightResponse"; const PACKAGE: &'static str = "cosmos.base.tendermint.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.tendermint.v1beta1.{}", Self::NAME) + "cosmos.base.tendermint.v1beta1.GetValidatorSetByHeightResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.tendermint.v1beta1.GetValidatorSetByHeightResponse".into() } } /// GetLatestValidatorSetRequest is the request type for the Query/GetValidatorSetByHeight RPC method. @@ -130,7 +143,10 @@ impl ::prost::Name for GetLatestValidatorSetRequest { const NAME: &'static str = "GetLatestValidatorSetRequest"; const PACKAGE: &'static str = "cosmos.base.tendermint.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.tendermint.v1beta1.{}", Self::NAME) + "cosmos.base.tendermint.v1beta1.GetLatestValidatorSetRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.tendermint.v1beta1.GetLatestValidatorSetRequest".into() } } /// GetLatestValidatorSetResponse is the response type for the Query/GetValidatorSetByHeight RPC method. @@ -149,7 +165,10 @@ impl ::prost::Name for GetLatestValidatorSetResponse { const NAME: &'static str = "GetLatestValidatorSetResponse"; const PACKAGE: &'static str = "cosmos.base.tendermint.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.tendermint.v1beta1.{}", Self::NAME) + "cosmos.base.tendermint.v1beta1.GetLatestValidatorSetResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.tendermint.v1beta1.GetLatestValidatorSetResponse".into() } } /// Validator is the type for the validator-set. @@ -171,7 +190,10 @@ impl ::prost::Name for Validator { const NAME: &'static str = "Validator"; const PACKAGE: &'static str = "cosmos.base.tendermint.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.tendermint.v1beta1.{}", Self::NAME) + "cosmos.base.tendermint.v1beta1.Validator".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.tendermint.v1beta1.Validator".into() } } /// GetBlockByHeightRequest is the request type for the Query/GetBlockByHeight RPC method. @@ -185,7 +207,10 @@ impl ::prost::Name for GetBlockByHeightRequest { const NAME: &'static str = "GetBlockByHeightRequest"; const PACKAGE: &'static str = "cosmos.base.tendermint.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.tendermint.v1beta1.{}", Self::NAME) + "cosmos.base.tendermint.v1beta1.GetBlockByHeightRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.tendermint.v1beta1.GetBlockByHeightRequest".into() } } /// GetBlockByHeightResponse is the response type for the Query/GetBlockByHeight RPC method. @@ -205,7 +230,10 @@ impl ::prost::Name for GetBlockByHeightResponse { const NAME: &'static str = "GetBlockByHeightResponse"; const PACKAGE: &'static str = "cosmos.base.tendermint.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.tendermint.v1beta1.{}", Self::NAME) + "cosmos.base.tendermint.v1beta1.GetBlockByHeightResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.tendermint.v1beta1.GetBlockByHeightResponse".into() } } /// GetLatestBlockRequest is the request type for the Query/GetLatestBlock RPC method. @@ -216,7 +244,10 @@ impl ::prost::Name for GetLatestBlockRequest { const NAME: &'static str = "GetLatestBlockRequest"; const PACKAGE: &'static str = "cosmos.base.tendermint.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.tendermint.v1beta1.{}", Self::NAME) + "cosmos.base.tendermint.v1beta1.GetLatestBlockRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.tendermint.v1beta1.GetLatestBlockRequest".into() } } /// GetLatestBlockResponse is the response type for the Query/GetLatestBlock RPC method. @@ -236,7 +267,10 @@ impl ::prost::Name for GetLatestBlockResponse { const NAME: &'static str = "GetLatestBlockResponse"; const PACKAGE: &'static str = "cosmos.base.tendermint.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.tendermint.v1beta1.{}", Self::NAME) + "cosmos.base.tendermint.v1beta1.GetLatestBlockResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.tendermint.v1beta1.GetLatestBlockResponse".into() } } /// GetSyncingRequest is the request type for the Query/GetSyncing RPC method. @@ -247,7 +281,10 @@ impl ::prost::Name for GetSyncingRequest { const NAME: &'static str = "GetSyncingRequest"; const PACKAGE: &'static str = "cosmos.base.tendermint.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.tendermint.v1beta1.{}", Self::NAME) + "cosmos.base.tendermint.v1beta1.GetSyncingRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.tendermint.v1beta1.GetSyncingRequest".into() } } /// GetSyncingResponse is the response type for the Query/GetSyncing RPC method. @@ -261,7 +298,10 @@ impl ::prost::Name for GetSyncingResponse { const NAME: &'static str = "GetSyncingResponse"; const PACKAGE: &'static str = "cosmos.base.tendermint.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.tendermint.v1beta1.{}", Self::NAME) + "cosmos.base.tendermint.v1beta1.GetSyncingResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.tendermint.v1beta1.GetSyncingResponse".into() } } /// GetNodeInfoRequest is the request type for the Query/GetNodeInfo RPC method. @@ -272,7 +312,10 @@ impl ::prost::Name for GetNodeInfoRequest { const NAME: &'static str = "GetNodeInfoRequest"; const PACKAGE: &'static str = "cosmos.base.tendermint.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.tendermint.v1beta1.{}", Self::NAME) + "cosmos.base.tendermint.v1beta1.GetNodeInfoRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.tendermint.v1beta1.GetNodeInfoRequest".into() } } /// GetNodeInfoResponse is the response type for the Query/GetNodeInfo RPC method. @@ -290,7 +333,10 @@ impl ::prost::Name for GetNodeInfoResponse { const NAME: &'static str = "GetNodeInfoResponse"; const PACKAGE: &'static str = "cosmos.base.tendermint.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.tendermint.v1beta1.{}", Self::NAME) + "cosmos.base.tendermint.v1beta1.GetNodeInfoResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.tendermint.v1beta1.GetNodeInfoResponse".into() } } /// VersionInfo is the type for the GetNodeInfoResponse message. @@ -319,7 +365,10 @@ impl ::prost::Name for VersionInfo { const NAME: &'static str = "VersionInfo"; const PACKAGE: &'static str = "cosmos.base.tendermint.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.tendermint.v1beta1.{}", Self::NAME) + "cosmos.base.tendermint.v1beta1.VersionInfo".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.tendermint.v1beta1.VersionInfo".into() } } /// Module is the type for VersionInfo @@ -340,7 +389,10 @@ impl ::prost::Name for Module { const NAME: &'static str = "Module"; const PACKAGE: &'static str = "cosmos.base.tendermint.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.tendermint.v1beta1.{}", Self::NAME) + "cosmos.base.tendermint.v1beta1.Module".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.tendermint.v1beta1.Module".into() } } /// ABCIQueryRequest defines the request structure for the ABCIQuery gRPC query. @@ -360,7 +412,10 @@ impl ::prost::Name for AbciQueryRequest { const NAME: &'static str = "ABCIQueryRequest"; const PACKAGE: &'static str = "cosmos.base.tendermint.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.tendermint.v1beta1.{}", Self::NAME) + "cosmos.base.tendermint.v1beta1.ABCIQueryRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.tendermint.v1beta1.ABCIQueryRequest".into() } } /// ABCIQueryResponse defines the response structure for the ABCIQuery gRPC query. @@ -395,7 +450,10 @@ impl ::prost::Name for AbciQueryResponse { const NAME: &'static str = "ABCIQueryResponse"; const PACKAGE: &'static str = "cosmos.base.tendermint.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.tendermint.v1beta1.{}", Self::NAME) + "cosmos.base.tendermint.v1beta1.ABCIQueryResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.tendermint.v1beta1.ABCIQueryResponse".into() } } /// ProofOp defines an operation used for calculating Merkle root. The data could @@ -417,7 +475,10 @@ impl ::prost::Name for ProofOp { const NAME: &'static str = "ProofOp"; const PACKAGE: &'static str = "cosmos.base.tendermint.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.tendermint.v1beta1.{}", Self::NAME) + "cosmos.base.tendermint.v1beta1.ProofOp".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.tendermint.v1beta1.ProofOp".into() } } /// ProofOps is Merkle proof defined by the list of ProofOps. @@ -433,7 +494,10 @@ impl ::prost::Name for ProofOps { const NAME: &'static str = "ProofOps"; const PACKAGE: &'static str = "cosmos.base.tendermint.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.tendermint.v1beta1.{}", Self::NAME) + "cosmos.base.tendermint.v1beta1.ProofOps".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.tendermint.v1beta1.ProofOps".into() } } /// Generated client implementations. diff --git a/src/prost/cosmos.base.v1beta1.rs b/src/prost/cosmos.base.v1beta1.rs index e3497310..057afb09 100644 --- a/src/prost/cosmos.base.v1beta1.rs +++ b/src/prost/cosmos.base.v1beta1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// Coin defines a token with a denomination and an amount. /// /// NOTE: The amount field is an Int which implements the custom method @@ -14,7 +15,10 @@ impl ::prost::Name for Coin { const NAME: &'static str = "Coin"; const PACKAGE: &'static str = "cosmos.base.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.v1beta1.{}", Self::NAME) + "cosmos.base.v1beta1.Coin".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.v1beta1.Coin".into() } } /// DecCoin defines a token with a denomination and a decimal amount. @@ -33,7 +37,10 @@ impl ::prost::Name for DecCoin { const NAME: &'static str = "DecCoin"; const PACKAGE: &'static str = "cosmos.base.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.v1beta1.{}", Self::NAME) + "cosmos.base.v1beta1.DecCoin".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.v1beta1.DecCoin".into() } } /// IntProto defines a Protobuf wrapper around an Int object. @@ -47,7 +54,10 @@ impl ::prost::Name for IntProto { const NAME: &'static str = "IntProto"; const PACKAGE: &'static str = "cosmos.base.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.v1beta1.{}", Self::NAME) + "cosmos.base.v1beta1.IntProto".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.v1beta1.IntProto".into() } } /// DecProto defines a Protobuf wrapper around a Dec object. @@ -61,6 +71,9 @@ impl ::prost::Name for DecProto { const NAME: &'static str = "DecProto"; const PACKAGE: &'static str = "cosmos.base.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.base.v1beta1.{}", Self::NAME) + "cosmos.base.v1beta1.DecProto".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.base.v1beta1.DecProto".into() } } diff --git a/src/prost/cosmos.crypto.ed25519.rs b/src/prost/cosmos.crypto.ed25519.rs index 4195c048..8c52ed2e 100644 --- a/src/prost/cosmos.crypto.ed25519.rs +++ b/src/prost/cosmos.crypto.ed25519.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// PubKey is an ed25519 public key for handling Tendermint keys in SDK. /// It's needed for Any serialization and SDK compatibility. /// It must not be used in a non Tendermint key context because it doesn't implement @@ -13,7 +14,10 @@ impl ::prost::Name for PubKey { const NAME: &'static str = "PubKey"; const PACKAGE: &'static str = "cosmos.crypto.ed25519"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.crypto.ed25519.{}", Self::NAME) + "cosmos.crypto.ed25519.PubKey".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.crypto.ed25519.PubKey".into() } } /// Deprecated: PrivKey defines a ed25519 private key. @@ -28,6 +32,9 @@ impl ::prost::Name for PrivKey { const NAME: &'static str = "PrivKey"; const PACKAGE: &'static str = "cosmos.crypto.ed25519"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.crypto.ed25519.{}", Self::NAME) + "cosmos.crypto.ed25519.PrivKey".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.crypto.ed25519.PrivKey".into() } } diff --git a/src/prost/cosmos.crypto.hd.v1.rs b/src/prost/cosmos.crypto.hd.v1.rs index d0b44bc6..a20ee312 100644 --- a/src/prost/cosmos.crypto.hd.v1.rs +++ b/src/prost/cosmos.crypto.hd.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// BIP44Params is used as path field in ledger item in Record. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, Copy, PartialEq, ::prost::Message)] @@ -23,6 +24,9 @@ impl ::prost::Name for Bip44Params { const NAME: &'static str = "BIP44Params"; const PACKAGE: &'static str = "cosmos.crypto.hd.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.crypto.hd.v1.{}", Self::NAME) + "cosmos.crypto.hd.v1.BIP44Params".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.crypto.hd.v1.BIP44Params".into() } } diff --git a/src/prost/cosmos.crypto.keyring.v1.rs b/src/prost/cosmos.crypto.keyring.v1.rs index 380b5dea..22ead0d6 100644 --- a/src/prost/cosmos.crypto.keyring.v1.rs +++ b/src/prost/cosmos.crypto.keyring.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// Record is used for representing a key in the keyring. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -30,7 +31,10 @@ pub mod record { const NAME: &'static str = "Local"; const PACKAGE: &'static str = "cosmos.crypto.keyring.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.crypto.keyring.v1.Record.{}", Self::NAME) + "cosmos.crypto.keyring.v1.Record.Local".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.crypto.keyring.v1.Record.Local".into() } } /// Ledger item @@ -44,7 +48,10 @@ pub mod record { const NAME: &'static str = "Ledger"; const PACKAGE: &'static str = "cosmos.crypto.keyring.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.crypto.keyring.v1.Record.{}", Self::NAME) + "cosmos.crypto.keyring.v1.Record.Ledger".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.crypto.keyring.v1.Record.Ledger".into() } } /// Multi item @@ -55,7 +62,10 @@ pub mod record { const NAME: &'static str = "Multi"; const PACKAGE: &'static str = "cosmos.crypto.keyring.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.crypto.keyring.v1.Record.{}", Self::NAME) + "cosmos.crypto.keyring.v1.Record.Multi".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.crypto.keyring.v1.Record.Multi".into() } } /// Offline item @@ -66,7 +76,10 @@ pub mod record { const NAME: &'static str = "Offline"; const PACKAGE: &'static str = "cosmos.crypto.keyring.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.crypto.keyring.v1.Record.{}", Self::NAME) + "cosmos.crypto.keyring.v1.Record.Offline".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.crypto.keyring.v1.Record.Offline".into() } } /// Record contains one of the following items @@ -91,6 +104,9 @@ impl ::prost::Name for Record { const NAME: &'static str = "Record"; const PACKAGE: &'static str = "cosmos.crypto.keyring.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.crypto.keyring.v1.{}", Self::NAME) + "cosmos.crypto.keyring.v1.Record".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.crypto.keyring.v1.Record".into() } } diff --git a/src/prost/cosmos.crypto.multisig.rs b/src/prost/cosmos.crypto.multisig.rs index 6455fb3d..c799f002 100644 --- a/src/prost/cosmos.crypto.multisig.rs +++ b/src/prost/cosmos.crypto.multisig.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// LegacyAminoPubKey specifies a public key type /// which nests multiple public keys and a threshold, /// it uses legacy amino address rules. @@ -15,6 +16,9 @@ impl ::prost::Name for LegacyAminoPubKey { const NAME: &'static str = "LegacyAminoPubKey"; const PACKAGE: &'static str = "cosmos.crypto.multisig"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.crypto.multisig.{}", Self::NAME) + "cosmos.crypto.multisig.LegacyAminoPubKey".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.crypto.multisig.LegacyAminoPubKey".into() } } diff --git a/src/prost/cosmos.crypto.multisig.v1beta1.rs b/src/prost/cosmos.crypto.multisig.v1beta1.rs index 1d784f69..ea870783 100644 --- a/src/prost/cosmos.crypto.multisig.v1beta1.rs +++ b/src/prost/cosmos.crypto.multisig.v1beta1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// MultiSignature wraps the signatures from a multisig.LegacyAminoPubKey. /// See cosmos.tx.v1betata1.ModeInfo.Multi for how to specify which signers /// signed and with which modes. @@ -11,7 +12,10 @@ impl ::prost::Name for MultiSignature { const NAME: &'static str = "MultiSignature"; const PACKAGE: &'static str = "cosmos.crypto.multisig.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.crypto.multisig.v1beta1.{}", Self::NAME) + "cosmos.crypto.multisig.v1beta1.MultiSignature".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.crypto.multisig.v1beta1.MultiSignature".into() } } /// CompactBitArray is an implementation of a space efficient bit array. @@ -30,6 +34,9 @@ impl ::prost::Name for CompactBitArray { const NAME: &'static str = "CompactBitArray"; const PACKAGE: &'static str = "cosmos.crypto.multisig.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.crypto.multisig.v1beta1.{}", Self::NAME) + "cosmos.crypto.multisig.v1beta1.CompactBitArray".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.crypto.multisig.v1beta1.CompactBitArray".into() } } diff --git a/src/prost/cosmos.crypto.secp256k1.rs b/src/prost/cosmos.crypto.secp256k1.rs index cafdb65e..fb4ba372 100644 --- a/src/prost/cosmos.crypto.secp256k1.rs +++ b/src/prost/cosmos.crypto.secp256k1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// PubKey defines a secp256k1 public key /// Key is the compressed form of the pubkey. The first byte depends is a 0x02 byte /// if the y-coordinate is the lexicographically largest of the two associated with @@ -13,7 +14,10 @@ impl ::prost::Name for PubKey { const NAME: &'static str = "PubKey"; const PACKAGE: &'static str = "cosmos.crypto.secp256k1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.crypto.secp256k1.{}", Self::NAME) + "cosmos.crypto.secp256k1.PubKey".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.crypto.secp256k1.PubKey".into() } } /// PrivKey defines a secp256k1 private key. @@ -27,6 +31,9 @@ impl ::prost::Name for PrivKey { const NAME: &'static str = "PrivKey"; const PACKAGE: &'static str = "cosmos.crypto.secp256k1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.crypto.secp256k1.{}", Self::NAME) + "cosmos.crypto.secp256k1.PrivKey".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.crypto.secp256k1.PrivKey".into() } } diff --git a/src/prost/cosmos.crypto.secp256r1.rs b/src/prost/cosmos.crypto.secp256r1.rs index 067eef4b..39ba3874 100644 --- a/src/prost/cosmos.crypto.secp256r1.rs +++ b/src/prost/cosmos.crypto.secp256r1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// PubKey defines a secp256r1 ECDSA public key. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -11,7 +12,10 @@ impl ::prost::Name for PubKey { const NAME: &'static str = "PubKey"; const PACKAGE: &'static str = "cosmos.crypto.secp256r1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.crypto.secp256r1.{}", Self::NAME) + "cosmos.crypto.secp256r1.PubKey".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.crypto.secp256r1.PubKey".into() } } /// PrivKey defines a secp256r1 ECDSA private key. @@ -26,6 +30,9 @@ impl ::prost::Name for PrivKey { const NAME: &'static str = "PrivKey"; const PACKAGE: &'static str = "cosmos.crypto.secp256r1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.crypto.secp256r1.{}", Self::NAME) + "cosmos.crypto.secp256r1.PrivKey".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.crypto.secp256r1.PrivKey".into() } } diff --git a/src/prost/cosmos.gov.module.v1.rs b/src/prost/cosmos.gov.module.v1.rs index 9a066d49..e7d5510c 100644 --- a/src/prost/cosmos.gov.module.v1.rs +++ b/src/prost/cosmos.gov.module.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// Module is the config object of the gov module. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -14,6 +15,9 @@ impl ::prost::Name for Module { const NAME: &'static str = "Module"; const PACKAGE: &'static str = "cosmos.gov.module.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.module.v1.{}", Self::NAME) + "cosmos.gov.module.v1.Module".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.module.v1.Module".into() } } diff --git a/src/prost/cosmos.gov.v1.rs b/src/prost/cosmos.gov.v1.rs index 92ffec6e..b7086b3b 100644 --- a/src/prost/cosmos.gov.v1.rs +++ b/src/prost/cosmos.gov.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// WeightedVoteOption defines a unit of vote for vote split. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -13,7 +14,10 @@ impl ::prost::Name for WeightedVoteOption { const NAME: &'static str = "WeightedVoteOption"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.WeightedVoteOption".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.WeightedVoteOption".into() } } /// Deposit defines an amount deposited by an account address to an active @@ -35,7 +39,10 @@ impl ::prost::Name for Deposit { const NAME: &'static str = "Deposit"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.Deposit".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.Deposit".into() } } /// Proposal defines the core field members of a governance proposal. @@ -102,7 +109,10 @@ impl ::prost::Name for Proposal { const NAME: &'static str = "Proposal"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.Proposal".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.Proposal".into() } } /// TallyResult defines a standard tally for a governance proposal. @@ -126,7 +136,10 @@ impl ::prost::Name for TallyResult { const NAME: &'static str = "TallyResult"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.TallyResult".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.TallyResult".into() } } /// Vote defines a vote on a governance proposal. @@ -151,7 +164,10 @@ impl ::prost::Name for Vote { const NAME: &'static str = "Vote"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.Vote".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.Vote".into() } } /// DepositParams defines the params for deposits on governance proposals. @@ -172,7 +188,10 @@ impl ::prost::Name for DepositParams { const NAME: &'static str = "DepositParams"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.DepositParams".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.DepositParams".into() } } /// VotingParams defines the params for voting on governance proposals. @@ -189,7 +208,10 @@ impl ::prost::Name for VotingParams { const NAME: &'static str = "VotingParams"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.VotingParams".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.VotingParams".into() } } /// TallyParams defines the params for tallying votes on governance proposals. @@ -212,7 +234,10 @@ impl ::prost::Name for TallyParams { const NAME: &'static str = "TallyParams"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.TallyParams".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.TallyParams".into() } } /// Params defines the parameters for the x/gov module. @@ -263,7 +288,10 @@ impl ::prost::Name for Params { const NAME: &'static str = "Params"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.Params".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.Params".into() } } /// VoteOption enumerates the valid vote options for a given governance proposal. @@ -389,7 +417,10 @@ impl ::prost::Name for MsgSubmitProposal { const NAME: &'static str = "MsgSubmitProposal"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.MsgSubmitProposal".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.MsgSubmitProposal".into() } } /// MsgSubmitProposalResponse defines the Msg/SubmitProposal response type. @@ -404,7 +435,10 @@ impl ::prost::Name for MsgSubmitProposalResponse { const NAME: &'static str = "MsgSubmitProposalResponse"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.MsgSubmitProposalResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.MsgSubmitProposalResponse".into() } } /// MsgExecLegacyContent is used to wrap the legacy content field into a message. @@ -423,7 +457,10 @@ impl ::prost::Name for MsgExecLegacyContent { const NAME: &'static str = "MsgExecLegacyContent"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.MsgExecLegacyContent".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.MsgExecLegacyContent".into() } } /// MsgExecLegacyContentResponse defines the Msg/ExecLegacyContent response type. @@ -434,7 +471,10 @@ impl ::prost::Name for MsgExecLegacyContentResponse { const NAME: &'static str = "MsgExecLegacyContentResponse"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.MsgExecLegacyContentResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.MsgExecLegacyContentResponse".into() } } /// MsgVote defines a message to cast a vote. @@ -458,7 +498,10 @@ impl ::prost::Name for MsgVote { const NAME: &'static str = "MsgVote"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.MsgVote".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.MsgVote".into() } } /// MsgVoteResponse defines the Msg/Vote response type. @@ -469,7 +512,10 @@ impl ::prost::Name for MsgVoteResponse { const NAME: &'static str = "MsgVoteResponse"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.MsgVoteResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.MsgVoteResponse".into() } } /// MsgVoteWeighted defines a message to cast a vote. @@ -493,7 +539,10 @@ impl ::prost::Name for MsgVoteWeighted { const NAME: &'static str = "MsgVoteWeighted"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.MsgVoteWeighted".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.MsgVoteWeighted".into() } } /// MsgVoteWeightedResponse defines the Msg/VoteWeighted response type. @@ -504,7 +553,10 @@ impl ::prost::Name for MsgVoteWeightedResponse { const NAME: &'static str = "MsgVoteWeightedResponse"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.MsgVoteWeightedResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.MsgVoteWeightedResponse".into() } } /// MsgDeposit defines a message to submit a deposit to an existing proposal. @@ -525,7 +577,10 @@ impl ::prost::Name for MsgDeposit { const NAME: &'static str = "MsgDeposit"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.MsgDeposit".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.MsgDeposit".into() } } /// MsgDepositResponse defines the Msg/Deposit response type. @@ -536,7 +591,10 @@ impl ::prost::Name for MsgDepositResponse { const NAME: &'static str = "MsgDepositResponse"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.MsgDepositResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.MsgDepositResponse".into() } } /// MsgUpdateParams is the Msg/UpdateParams request type. @@ -558,7 +616,10 @@ impl ::prost::Name for MsgUpdateParams { const NAME: &'static str = "MsgUpdateParams"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.MsgUpdateParams".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.MsgUpdateParams".into() } } /// MsgUpdateParamsResponse defines the response structure for executing a @@ -572,7 +633,10 @@ impl ::prost::Name for MsgUpdateParamsResponse { const NAME: &'static str = "MsgUpdateParamsResponse"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.MsgUpdateParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.MsgUpdateParamsResponse".into() } } /// Generated client implementations. @@ -1259,7 +1323,10 @@ impl ::prost::Name for QueryProposalRequest { const NAME: &'static str = "QueryProposalRequest"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.QueryProposalRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.QueryProposalRequest".into() } } /// QueryProposalResponse is the response type for the Query/Proposal RPC method. @@ -1274,7 +1341,10 @@ impl ::prost::Name for QueryProposalResponse { const NAME: &'static str = "QueryProposalResponse"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.QueryProposalResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.QueryProposalResponse".into() } } /// QueryProposalsRequest is the request type for the Query/Proposals RPC method. @@ -1300,7 +1370,10 @@ impl ::prost::Name for QueryProposalsRequest { const NAME: &'static str = "QueryProposalsRequest"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.QueryProposalsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.QueryProposalsRequest".into() } } /// QueryProposalsResponse is the response type for the Query/Proposals RPC @@ -1321,7 +1394,10 @@ impl ::prost::Name for QueryProposalsResponse { const NAME: &'static str = "QueryProposalsResponse"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.QueryProposalsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.QueryProposalsResponse".into() } } /// QueryVoteRequest is the request type for the Query/Vote RPC method. @@ -1339,7 +1415,10 @@ impl ::prost::Name for QueryVoteRequest { const NAME: &'static str = "QueryVoteRequest"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.QueryVoteRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.QueryVoteRequest".into() } } /// QueryVoteResponse is the response type for the Query/Vote RPC method. @@ -1354,7 +1433,10 @@ impl ::prost::Name for QueryVoteResponse { const NAME: &'static str = "QueryVoteResponse"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.QueryVoteResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.QueryVoteResponse".into() } } /// QueryVotesRequest is the request type for the Query/Votes RPC method. @@ -1374,7 +1456,10 @@ impl ::prost::Name for QueryVotesRequest { const NAME: &'static str = "QueryVotesRequest"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.QueryVotesRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.QueryVotesRequest".into() } } /// QueryVotesResponse is the response type for the Query/Votes RPC method. @@ -1394,7 +1479,10 @@ impl ::prost::Name for QueryVotesResponse { const NAME: &'static str = "QueryVotesResponse"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.QueryVotesResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.QueryVotesResponse".into() } } /// QueryParamsRequest is the request type for the Query/Params RPC method. @@ -1410,7 +1498,10 @@ impl ::prost::Name for QueryParamsRequest { const NAME: &'static str = "QueryParamsRequest"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.QueryParamsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.QueryParamsRequest".into() } } /// QueryParamsResponse is the response type for the Query/Params RPC method. @@ -1442,7 +1533,10 @@ impl ::prost::Name for QueryParamsResponse { const NAME: &'static str = "QueryParamsResponse"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.QueryParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.QueryParamsResponse".into() } } /// QueryDepositRequest is the request type for the Query/Deposit RPC method. @@ -1460,7 +1554,10 @@ impl ::prost::Name for QueryDepositRequest { const NAME: &'static str = "QueryDepositRequest"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.QueryDepositRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.QueryDepositRequest".into() } } /// QueryDepositResponse is the response type for the Query/Deposit RPC method. @@ -1475,7 +1572,10 @@ impl ::prost::Name for QueryDepositResponse { const NAME: &'static str = "QueryDepositResponse"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.QueryDepositResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.QueryDepositResponse".into() } } /// QueryDepositsRequest is the request type for the Query/Deposits RPC method. @@ -1495,7 +1595,10 @@ impl ::prost::Name for QueryDepositsRequest { const NAME: &'static str = "QueryDepositsRequest"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.QueryDepositsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.QueryDepositsRequest".into() } } /// QueryDepositsResponse is the response type for the Query/Deposits RPC method. @@ -1515,7 +1618,10 @@ impl ::prost::Name for QueryDepositsResponse { const NAME: &'static str = "QueryDepositsResponse"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.QueryDepositsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.QueryDepositsResponse".into() } } /// QueryTallyResultRequest is the request type for the Query/Tally RPC method. @@ -1530,7 +1636,10 @@ impl ::prost::Name for QueryTallyResultRequest { const NAME: &'static str = "QueryTallyResultRequest"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.QueryTallyResultRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.QueryTallyResultRequest".into() } } /// QueryTallyResultResponse is the response type for the Query/Tally RPC method. @@ -1545,7 +1654,10 @@ impl ::prost::Name for QueryTallyResultResponse { const NAME: &'static str = "QueryTallyResultResponse"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.QueryTallyResultResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.QueryTallyResultResponse".into() } } /// Generated client implementations. @@ -2420,6 +2532,9 @@ impl ::prost::Name for GenesisState { const NAME: &'static str = "GenesisState"; const PACKAGE: &'static str = "cosmos.gov.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1.{}", Self::NAME) + "cosmos.gov.v1.GenesisState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1.GenesisState".into() } } diff --git a/src/prost/cosmos.gov.v1beta1.rs b/src/prost/cosmos.gov.v1beta1.rs index a524020a..4028f192 100644 --- a/src/prost/cosmos.gov.v1beta1.rs +++ b/src/prost/cosmos.gov.v1beta1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// WeightedVoteOption defines a unit of vote for vote split. /// /// Since: cosmos-sdk 0.43 @@ -15,7 +16,10 @@ impl ::prost::Name for WeightedVoteOption { const NAME: &'static str = "WeightedVoteOption"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.WeightedVoteOption".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.WeightedVoteOption".into() } } /// TextProposal defines a standard text proposal whose changes need to be @@ -34,7 +38,10 @@ impl ::prost::Name for TextProposal { const NAME: &'static str = "TextProposal"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.TextProposal".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.TextProposal".into() } } /// Deposit defines an amount deposited by an account address to an active @@ -56,7 +63,10 @@ impl ::prost::Name for Deposit { const NAME: &'static str = "Deposit"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.Deposit".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.Deposit".into() } } /// Proposal defines the core field members of a governance proposal. @@ -105,7 +115,10 @@ impl ::prost::Name for Proposal { const NAME: &'static str = "Proposal"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.Proposal".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.Proposal".into() } } /// TallyResult defines a standard tally for a governance proposal. @@ -129,7 +142,10 @@ impl ::prost::Name for TallyResult { const NAME: &'static str = "TallyResult"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.TallyResult".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.TallyResult".into() } } /// Vote defines a vote on a governance proposal. @@ -159,7 +175,10 @@ impl ::prost::Name for Vote { const NAME: &'static str = "Vote"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.Vote".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.Vote".into() } } /// DepositParams defines the params for deposits on governance proposals. @@ -180,7 +199,10 @@ impl ::prost::Name for DepositParams { const NAME: &'static str = "DepositParams"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.DepositParams".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.DepositParams".into() } } /// VotingParams defines the params for voting on governance proposals. @@ -197,7 +219,10 @@ impl ::prost::Name for VotingParams { const NAME: &'static str = "VotingParams"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.VotingParams".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.VotingParams".into() } } /// TallyParams defines the params for tallying votes on governance proposals. @@ -220,7 +245,10 @@ impl ::prost::Name for TallyParams { const NAME: &'static str = "TallyParams"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.TallyParams".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.TallyParams".into() } } /// VoteOption enumerates the valid vote options for a given governance proposal. @@ -333,7 +361,10 @@ impl ::prost::Name for MsgSubmitProposal { const NAME: &'static str = "MsgSubmitProposal"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.MsgSubmitProposal".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.MsgSubmitProposal".into() } } /// MsgSubmitProposalResponse defines the Msg/SubmitProposal response type. @@ -348,7 +379,10 @@ impl ::prost::Name for MsgSubmitProposalResponse { const NAME: &'static str = "MsgSubmitProposalResponse"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.MsgSubmitProposalResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.MsgSubmitProposalResponse".into() } } /// MsgVote defines a message to cast a vote. @@ -369,7 +403,10 @@ impl ::prost::Name for MsgVote { const NAME: &'static str = "MsgVote"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.MsgVote".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.MsgVote".into() } } /// MsgVoteResponse defines the Msg/Vote response type. @@ -380,7 +417,10 @@ impl ::prost::Name for MsgVoteResponse { const NAME: &'static str = "MsgVoteResponse"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.MsgVoteResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.MsgVoteResponse".into() } } /// MsgVoteWeighted defines a message to cast a vote. @@ -403,7 +443,10 @@ impl ::prost::Name for MsgVoteWeighted { const NAME: &'static str = "MsgVoteWeighted"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.MsgVoteWeighted".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.MsgVoteWeighted".into() } } /// MsgVoteWeightedResponse defines the Msg/VoteWeighted response type. @@ -416,7 +459,10 @@ impl ::prost::Name for MsgVoteWeightedResponse { const NAME: &'static str = "MsgVoteWeightedResponse"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.MsgVoteWeightedResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.MsgVoteWeightedResponse".into() } } /// MsgDeposit defines a message to submit a deposit to an existing proposal. @@ -437,7 +483,10 @@ impl ::prost::Name for MsgDeposit { const NAME: &'static str = "MsgDeposit"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.MsgDeposit".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.MsgDeposit".into() } } /// MsgDepositResponse defines the Msg/Deposit response type. @@ -448,7 +497,10 @@ impl ::prost::Name for MsgDepositResponse { const NAME: &'static str = "MsgDepositResponse"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.MsgDepositResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.MsgDepositResponse".into() } } /// Generated client implementations. @@ -981,7 +1033,10 @@ impl ::prost::Name for QueryProposalRequest { const NAME: &'static str = "QueryProposalRequest"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.QueryProposalRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.QueryProposalRequest".into() } } /// QueryProposalResponse is the response type for the Query/Proposal RPC method. @@ -995,7 +1050,10 @@ impl ::prost::Name for QueryProposalResponse { const NAME: &'static str = "QueryProposalResponse"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.QueryProposalResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.QueryProposalResponse".into() } } /// QueryProposalsRequest is the request type for the Query/Proposals RPC method. @@ -1021,7 +1079,10 @@ impl ::prost::Name for QueryProposalsRequest { const NAME: &'static str = "QueryProposalsRequest"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.QueryProposalsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.QueryProposalsRequest".into() } } /// QueryProposalsResponse is the response type for the Query/Proposals RPC @@ -1042,7 +1103,10 @@ impl ::prost::Name for QueryProposalsResponse { const NAME: &'static str = "QueryProposalsResponse"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.QueryProposalsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.QueryProposalsResponse".into() } } /// QueryVoteRequest is the request type for the Query/Vote RPC method. @@ -1060,7 +1124,10 @@ impl ::prost::Name for QueryVoteRequest { const NAME: &'static str = "QueryVoteRequest"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.QueryVoteRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.QueryVoteRequest".into() } } /// QueryVoteResponse is the response type for the Query/Vote RPC method. @@ -1075,7 +1142,10 @@ impl ::prost::Name for QueryVoteResponse { const NAME: &'static str = "QueryVoteResponse"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.QueryVoteResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.QueryVoteResponse".into() } } /// QueryVotesRequest is the request type for the Query/Votes RPC method. @@ -1095,7 +1165,10 @@ impl ::prost::Name for QueryVotesRequest { const NAME: &'static str = "QueryVotesRequest"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.QueryVotesRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.QueryVotesRequest".into() } } /// QueryVotesResponse is the response type for the Query/Votes RPC method. @@ -1115,7 +1188,10 @@ impl ::prost::Name for QueryVotesResponse { const NAME: &'static str = "QueryVotesResponse"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.QueryVotesResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.QueryVotesResponse".into() } } /// QueryParamsRequest is the request type for the Query/Params RPC method. @@ -1131,7 +1207,10 @@ impl ::prost::Name for QueryParamsRequest { const NAME: &'static str = "QueryParamsRequest"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.QueryParamsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.QueryParamsRequest".into() } } /// QueryParamsResponse is the response type for the Query/Params RPC method. @@ -1152,7 +1231,10 @@ impl ::prost::Name for QueryParamsResponse { const NAME: &'static str = "QueryParamsResponse"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.QueryParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.QueryParamsResponse".into() } } /// QueryDepositRequest is the request type for the Query/Deposit RPC method. @@ -1170,7 +1252,10 @@ impl ::prost::Name for QueryDepositRequest { const NAME: &'static str = "QueryDepositRequest"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.QueryDepositRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.QueryDepositRequest".into() } } /// QueryDepositResponse is the response type for the Query/Deposit RPC method. @@ -1185,7 +1270,10 @@ impl ::prost::Name for QueryDepositResponse { const NAME: &'static str = "QueryDepositResponse"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.QueryDepositResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.QueryDepositResponse".into() } } /// QueryDepositsRequest is the request type for the Query/Deposits RPC method. @@ -1205,7 +1293,10 @@ impl ::prost::Name for QueryDepositsRequest { const NAME: &'static str = "QueryDepositsRequest"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.QueryDepositsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.QueryDepositsRequest".into() } } /// QueryDepositsResponse is the response type for the Query/Deposits RPC method. @@ -1225,7 +1316,10 @@ impl ::prost::Name for QueryDepositsResponse { const NAME: &'static str = "QueryDepositsResponse"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.QueryDepositsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.QueryDepositsResponse".into() } } /// QueryTallyResultRequest is the request type for the Query/Tally RPC method. @@ -1240,7 +1334,10 @@ impl ::prost::Name for QueryTallyResultRequest { const NAME: &'static str = "QueryTallyResultRequest"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.QueryTallyResultRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.QueryTallyResultRequest".into() } } /// QueryTallyResultResponse is the response type for the Query/Tally RPC method. @@ -1255,7 +1352,10 @@ impl ::prost::Name for QueryTallyResultResponse { const NAME: &'static str = "QueryTallyResultResponse"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.QueryTallyResultResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.QueryTallyResultResponse".into() } } /// Generated client implementations. @@ -2123,6 +2223,9 @@ impl ::prost::Name for GenesisState { const NAME: &'static str = "GenesisState"; const PACKAGE: &'static str = "cosmos.gov.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.gov.v1beta1.{}", Self::NAME) + "cosmos.gov.v1beta1.GenesisState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.gov.v1beta1.GenesisState".into() } } diff --git a/src/prost/cosmos.staking.module.v1.rs b/src/prost/cosmos.staking.module.v1.rs index 2a8d086b..803365bf 100644 --- a/src/prost/cosmos.staking.module.v1.rs +++ b/src/prost/cosmos.staking.module.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// Module is the config object of the staking module. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -15,6 +16,9 @@ impl ::prost::Name for Module { const NAME: &'static str = "Module"; const PACKAGE: &'static str = "cosmos.staking.module.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.module.v1.{}", Self::NAME) + "cosmos.staking.module.v1.Module".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.module.v1.Module".into() } } diff --git a/src/prost/cosmos.staking.v1beta1.rs b/src/prost/cosmos.staking.v1beta1.rs index 4179f2b0..2a92fb35 100644 --- a/src/prost/cosmos.staking.v1beta1.rs +++ b/src/prost/cosmos.staking.v1beta1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// HistoricalInfo contains header and validator information for a given block. /// It is stored as part of staking module's state, which persists the `n` most /// recent HistoricalInfo @@ -14,7 +15,10 @@ impl ::prost::Name for HistoricalInfo { const NAME: &'static str = "HistoricalInfo"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.HistoricalInfo".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.HistoricalInfo".into() } } /// CommissionRates defines the initial commission rates to be used for creating @@ -36,7 +40,10 @@ impl ::prost::Name for CommissionRates { const NAME: &'static str = "CommissionRates"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.CommissionRates".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.CommissionRates".into() } } /// Commission defines commission parameters for a given validator. @@ -56,7 +63,10 @@ impl ::prost::Name for Commission { const NAME: &'static str = "Commission"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.Commission".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.Commission".into() } } /// Description defines a validator description. @@ -83,7 +93,10 @@ impl ::prost::Name for Description { const NAME: &'static str = "Description"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.Description".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.Description".into() } } /// Validator defines a validator, together with the total amount of the @@ -147,7 +160,10 @@ impl ::prost::Name for Validator { const NAME: &'static str = "Validator"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.Validator".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.Validator".into() } } /// ValAddresses defines a repeated set of validator addresses. @@ -161,7 +177,10 @@ impl ::prost::Name for ValAddresses { const NAME: &'static str = "ValAddresses"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.ValAddresses".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.ValAddresses".into() } } /// DVPair is struct that just has a delegator-validator pair with no other data. @@ -179,7 +198,10 @@ impl ::prost::Name for DvPair { const NAME: &'static str = "DVPair"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.DVPair".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.DVPair".into() } } /// DVPairs defines an array of DVPair objects. @@ -193,7 +215,10 @@ impl ::prost::Name for DvPairs { const NAME: &'static str = "DVPairs"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.DVPairs".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.DVPairs".into() } } /// DVVTriplet is struct that just has a delegator-validator-validator triplet @@ -214,7 +239,10 @@ impl ::prost::Name for DvvTriplet { const NAME: &'static str = "DVVTriplet"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.DVVTriplet".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.DVVTriplet".into() } } /// DVVTriplets defines an array of DVVTriplet objects. @@ -228,7 +256,10 @@ impl ::prost::Name for DvvTriplets { const NAME: &'static str = "DVVTriplets"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.DVVTriplets".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.DVVTriplets".into() } } /// Delegation represents the bond with tokens held by an account. It is @@ -251,7 +282,10 @@ impl ::prost::Name for Delegation { const NAME: &'static str = "Delegation"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.Delegation".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.Delegation".into() } } /// UnbondingDelegation stores all of a single delegator's unbonding bonds @@ -275,7 +309,10 @@ impl ::prost::Name for UnbondingDelegation { const NAME: &'static str = "UnbondingDelegation"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.UnbondingDelegation".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.UnbondingDelegation".into() } } /// UnbondingDelegationEntry defines an unbonding object with relevant metadata. @@ -307,7 +344,10 @@ impl ::prost::Name for UnbondingDelegationEntry { const NAME: &'static str = "UnbondingDelegationEntry"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.UnbondingDelegationEntry".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.UnbondingDelegationEntry".into() } } /// RedelegationEntry defines a redelegation object with relevant metadata. @@ -339,7 +379,10 @@ impl ::prost::Name for RedelegationEntry { const NAME: &'static str = "RedelegationEntry"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.RedelegationEntry".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.RedelegationEntry".into() } } /// Redelegation contains the list of a particular delegator's redelegating bonds @@ -366,7 +409,10 @@ impl ::prost::Name for Redelegation { const NAME: &'static str = "Redelegation"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.Redelegation".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.Redelegation".into() } } /// Params defines the parameters for the x/staking module. @@ -398,7 +444,10 @@ impl ::prost::Name for Params { const NAME: &'static str = "Params"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.Params".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.Params".into() } } /// DelegationResponse is equivalent to Delegation except that it contains a @@ -415,7 +464,10 @@ impl ::prost::Name for DelegationResponse { const NAME: &'static str = "DelegationResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.DelegationResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.DelegationResponse".into() } } /// RedelegationEntryResponse is equivalent to a RedelegationEntry except that it @@ -433,7 +485,10 @@ impl ::prost::Name for RedelegationEntryResponse { const NAME: &'static str = "RedelegationEntryResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.RedelegationEntryResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.RedelegationEntryResponse".into() } } /// RedelegationResponse is equivalent to a Redelegation except that its entries @@ -451,7 +506,10 @@ impl ::prost::Name for RedelegationResponse { const NAME: &'static str = "RedelegationResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.RedelegationResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.RedelegationResponse".into() } } /// Pool is used for tracking bonded and not-bonded token supply of the bond @@ -468,7 +526,10 @@ impl ::prost::Name for Pool { const NAME: &'static str = "Pool"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.Pool".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.Pool".into() } } /// ValidatorUpdates defines an array of abci.ValidatorUpdate objects. @@ -483,7 +544,10 @@ impl ::prost::Name for ValidatorUpdates { const NAME: &'static str = "ValidatorUpdates"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.ValidatorUpdates".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.ValidatorUpdates".into() } } /// BondStatus is the status of a validator. @@ -612,7 +676,10 @@ impl ::prost::Name for MsgCreateValidator { const NAME: &'static str = "MsgCreateValidator"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.MsgCreateValidator".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.MsgCreateValidator".into() } } /// MsgCreateValidatorResponse defines the Msg/CreateValidator response type. @@ -623,7 +690,10 @@ impl ::prost::Name for MsgCreateValidatorResponse { const NAME: &'static str = "MsgCreateValidatorResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.MsgCreateValidatorResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.MsgCreateValidatorResponse".into() } } /// MsgEditValidator defines a SDK message for editing an existing validator. @@ -647,7 +717,10 @@ impl ::prost::Name for MsgEditValidator { const NAME: &'static str = "MsgEditValidator"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.MsgEditValidator".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.MsgEditValidator".into() } } /// MsgEditValidatorResponse defines the Msg/EditValidator response type. @@ -658,7 +731,10 @@ impl ::prost::Name for MsgEditValidatorResponse { const NAME: &'static str = "MsgEditValidatorResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.MsgEditValidatorResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.MsgEditValidatorResponse".into() } } /// MsgDelegate defines a SDK message for performing a delegation of coins @@ -677,7 +753,10 @@ impl ::prost::Name for MsgDelegate { const NAME: &'static str = "MsgDelegate"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.MsgDelegate".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.MsgDelegate".into() } } /// MsgDelegateResponse defines the Msg/Delegate response type. @@ -688,7 +767,10 @@ impl ::prost::Name for MsgDelegateResponse { const NAME: &'static str = "MsgDelegateResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.MsgDelegateResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.MsgDelegateResponse".into() } } /// MsgBeginRedelegate defines a SDK message for performing a redelegation @@ -709,7 +791,10 @@ impl ::prost::Name for MsgBeginRedelegate { const NAME: &'static str = "MsgBeginRedelegate"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.MsgBeginRedelegate".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.MsgBeginRedelegate".into() } } /// MsgBeginRedelegateResponse defines the Msg/BeginRedelegate response type. @@ -725,7 +810,10 @@ impl ::prost::Name for MsgBeginRedelegateResponse { const NAME: &'static str = "MsgBeginRedelegateResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.MsgBeginRedelegateResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.MsgBeginRedelegateResponse".into() } } /// MsgUndelegate defines a SDK message for performing an undelegation from a @@ -744,7 +832,10 @@ impl ::prost::Name for MsgUndelegate { const NAME: &'static str = "MsgUndelegate"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.MsgUndelegate".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.MsgUndelegate".into() } } /// MsgUndelegateResponse defines the Msg/Undelegate response type. @@ -760,7 +851,10 @@ impl ::prost::Name for MsgUndelegateResponse { const NAME: &'static str = "MsgUndelegateResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.MsgUndelegateResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.MsgUndelegateResponse".into() } } /// MsgCancelUnbondingDelegation defines the SDK message for performing a cancel unbonding delegation for delegator @@ -784,7 +878,10 @@ impl ::prost::Name for MsgCancelUnbondingDelegation { const NAME: &'static str = "MsgCancelUnbondingDelegation"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.MsgCancelUnbondingDelegation".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.MsgCancelUnbondingDelegation".into() } } /// MsgCancelUnbondingDelegationResponse @@ -797,7 +894,10 @@ impl ::prost::Name for MsgCancelUnbondingDelegationResponse { const NAME: &'static str = "MsgCancelUnbondingDelegationResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.MsgCancelUnbondingDelegationResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.MsgCancelUnbondingDelegationResponse".into() } } /// MsgUpdateParams is the Msg/UpdateParams request type. @@ -819,7 +919,10 @@ impl ::prost::Name for MsgUpdateParams { const NAME: &'static str = "MsgUpdateParams"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.MsgUpdateParams".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.MsgUpdateParams".into() } } /// MsgUpdateParamsResponse defines the response structure for executing a @@ -833,7 +936,10 @@ impl ::prost::Name for MsgUpdateParamsResponse { const NAME: &'static str = "MsgUpdateParamsResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.MsgUpdateParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.MsgUpdateParamsResponse".into() } } /// Generated client implementations. @@ -1629,7 +1735,10 @@ impl ::prost::Name for QueryValidatorsRequest { const NAME: &'static str = "QueryValidatorsRequest"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryValidatorsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryValidatorsRequest".into() } } /// QueryValidatorsResponse is response type for the Query/Validators RPC method @@ -1649,7 +1758,10 @@ impl ::prost::Name for QueryValidatorsResponse { const NAME: &'static str = "QueryValidatorsResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryValidatorsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryValidatorsResponse".into() } } /// QueryValidatorRequest is response type for the Query/Validator RPC method @@ -1664,7 +1776,10 @@ impl ::prost::Name for QueryValidatorRequest { const NAME: &'static str = "QueryValidatorRequest"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryValidatorRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryValidatorRequest".into() } } /// QueryValidatorResponse is response type for the Query/Validator RPC method @@ -1679,7 +1794,10 @@ impl ::prost::Name for QueryValidatorResponse { const NAME: &'static str = "QueryValidatorResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryValidatorResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryValidatorResponse".into() } } /// QueryValidatorDelegationsRequest is request type for the @@ -1700,7 +1818,10 @@ impl ::prost::Name for QueryValidatorDelegationsRequest { const NAME: &'static str = "QueryValidatorDelegationsRequest"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryValidatorDelegationsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryValidatorDelegationsRequest".into() } } /// QueryValidatorDelegationsResponse is response type for the @@ -1720,7 +1841,10 @@ impl ::prost::Name for QueryValidatorDelegationsResponse { const NAME: &'static str = "QueryValidatorDelegationsResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryValidatorDelegationsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryValidatorDelegationsResponse".into() } } /// QueryValidatorUnbondingDelegationsRequest is required type for the @@ -1741,7 +1865,10 @@ impl ::prost::Name for QueryValidatorUnbondingDelegationsRequest { const NAME: &'static str = "QueryValidatorUnbondingDelegationsRequest"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest".into() } } /// QueryValidatorUnbondingDelegationsResponse is response type for the @@ -1761,7 +1888,10 @@ impl ::prost::Name for QueryValidatorUnbondingDelegationsResponse { const NAME: &'static str = "QueryValidatorUnbondingDelegationsResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse".into() } } /// QueryDelegationRequest is request type for the Query/Delegation RPC method. @@ -1779,7 +1909,10 @@ impl ::prost::Name for QueryDelegationRequest { const NAME: &'static str = "QueryDelegationRequest"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryDelegationRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryDelegationRequest".into() } } /// QueryDelegationResponse is response type for the Query/Delegation RPC method. @@ -1794,7 +1927,10 @@ impl ::prost::Name for QueryDelegationResponse { const NAME: &'static str = "QueryDelegationResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryDelegationResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryDelegationResponse".into() } } /// QueryUnbondingDelegationRequest is request type for the @@ -1813,7 +1949,10 @@ impl ::prost::Name for QueryUnbondingDelegationRequest { const NAME: &'static str = "QueryUnbondingDelegationRequest"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryUnbondingDelegationRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryUnbondingDelegationRequest".into() } } /// QueryDelegationResponse is response type for the Query/UnbondingDelegation @@ -1829,7 +1968,10 @@ impl ::prost::Name for QueryUnbondingDelegationResponse { const NAME: &'static str = "QueryUnbondingDelegationResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryUnbondingDelegationResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryUnbondingDelegationResponse".into() } } /// QueryDelegatorDelegationsRequest is request type for the @@ -1850,7 +1992,10 @@ impl ::prost::Name for QueryDelegatorDelegationsRequest { const NAME: &'static str = "QueryDelegatorDelegationsRequest"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest".into() } } /// QueryDelegatorDelegationsResponse is response type for the @@ -1871,7 +2016,10 @@ impl ::prost::Name for QueryDelegatorDelegationsResponse { const NAME: &'static str = "QueryDelegatorDelegationsResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse".into() } } /// QueryDelegatorUnbondingDelegationsRequest is request type for the @@ -1892,7 +2040,10 @@ impl ::prost::Name for QueryDelegatorUnbondingDelegationsRequest { const NAME: &'static str = "QueryDelegatorUnbondingDelegationsRequest"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest".into() } } /// QueryUnbondingDelegatorDelegationsResponse is response type for the @@ -1912,7 +2063,10 @@ impl ::prost::Name for QueryDelegatorUnbondingDelegationsResponse { const NAME: &'static str = "QueryDelegatorUnbondingDelegationsResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse".into() } } /// QueryRedelegationsRequest is request type for the Query/Redelegations RPC @@ -1939,7 +2093,10 @@ impl ::prost::Name for QueryRedelegationsRequest { const NAME: &'static str = "QueryRedelegationsRequest"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryRedelegationsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryRedelegationsRequest".into() } } /// QueryRedelegationsResponse is response type for the Query/Redelegations RPC @@ -1959,7 +2116,10 @@ impl ::prost::Name for QueryRedelegationsResponse { const NAME: &'static str = "QueryRedelegationsResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryRedelegationsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryRedelegationsResponse".into() } } /// QueryDelegatorValidatorsRequest is request type for the @@ -1980,7 +2140,10 @@ impl ::prost::Name for QueryDelegatorValidatorsRequest { const NAME: &'static str = "QueryDelegatorValidatorsRequest"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest".into() } } /// QueryDelegatorValidatorsResponse is response type for the @@ -2001,7 +2164,10 @@ impl ::prost::Name for QueryDelegatorValidatorsResponse { const NAME: &'static str = "QueryDelegatorValidatorsResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse".into() } } /// QueryDelegatorValidatorRequest is request type for the @@ -2020,7 +2186,10 @@ impl ::prost::Name for QueryDelegatorValidatorRequest { const NAME: &'static str = "QueryDelegatorValidatorRequest"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryDelegatorValidatorRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryDelegatorValidatorRequest".into() } } /// QueryDelegatorValidatorResponse response type for the @@ -2036,7 +2205,10 @@ impl ::prost::Name for QueryDelegatorValidatorResponse { const NAME: &'static str = "QueryDelegatorValidatorResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryDelegatorValidatorResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryDelegatorValidatorResponse".into() } } /// QueryHistoricalInfoRequest is request type for the Query/HistoricalInfo RPC @@ -2052,7 +2224,10 @@ impl ::prost::Name for QueryHistoricalInfoRequest { const NAME: &'static str = "QueryHistoricalInfoRequest"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryHistoricalInfoRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryHistoricalInfoRequest".into() } } /// QueryHistoricalInfoResponse is response type for the Query/HistoricalInfo RPC @@ -2068,7 +2243,10 @@ impl ::prost::Name for QueryHistoricalInfoResponse { const NAME: &'static str = "QueryHistoricalInfoResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryHistoricalInfoResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryHistoricalInfoResponse".into() } } /// QueryPoolRequest is request type for the Query/Pool RPC method. @@ -2079,7 +2257,10 @@ impl ::prost::Name for QueryPoolRequest { const NAME: &'static str = "QueryPoolRequest"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryPoolRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryPoolRequest".into() } } /// QueryPoolResponse is response type for the Query/Pool RPC method. @@ -2094,7 +2275,10 @@ impl ::prost::Name for QueryPoolResponse { const NAME: &'static str = "QueryPoolResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryPoolResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryPoolResponse".into() } } /// QueryParamsRequest is request type for the Query/Params RPC method. @@ -2105,7 +2289,10 @@ impl ::prost::Name for QueryParamsRequest { const NAME: &'static str = "QueryParamsRequest"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryParamsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryParamsRequest".into() } } /// QueryParamsResponse is response type for the Query/Params RPC method. @@ -2120,7 +2307,10 @@ impl ::prost::Name for QueryParamsResponse { const NAME: &'static str = "QueryParamsResponse"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.QueryParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.QueryParamsResponse".into() } } /// Generated client implementations. @@ -3580,9 +3770,10 @@ pub mod stake_authorization { const NAME: &'static str = "Validators"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "cosmos.staking.v1beta1.StakeAuthorization.{}", Self::NAME - ) + "cosmos.staking.v1beta1.StakeAuthorization.Validators".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.StakeAuthorization.Validators".into() } } /// validators is the oneof that represents either allow_list or deny_list @@ -3602,7 +3793,10 @@ impl ::prost::Name for StakeAuthorization { const NAME: &'static str = "StakeAuthorization"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.StakeAuthorization".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.StakeAuthorization".into() } } /// AuthorizationType defines the type of staking module authorization type @@ -3678,7 +3872,10 @@ impl ::prost::Name for GenesisState { const NAME: &'static str = "GenesisState"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.GenesisState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.GenesisState".into() } } /// LastValidatorPower required for validator set update logic. @@ -3696,6 +3893,9 @@ impl ::prost::Name for LastValidatorPower { const NAME: &'static str = "LastValidatorPower"; const PACKAGE: &'static str = "cosmos.staking.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.staking.v1beta1.{}", Self::NAME) + "cosmos.staking.v1beta1.LastValidatorPower".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.staking.v1beta1.LastValidatorPower".into() } } diff --git a/src/prost/cosmos.tx.config.v1.rs b/src/prost/cosmos.tx.config.v1.rs index a839fe8b..2020b0b5 100644 --- a/src/prost/cosmos.tx.config.v1.rs +++ b/src/prost/cosmos.tx.config.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// Config is the config object of the x/auth/tx package. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, Copy, PartialEq, ::prost::Message)] @@ -15,6 +16,9 @@ impl ::prost::Name for Config { const NAME: &'static str = "Config"; const PACKAGE: &'static str = "cosmos.tx.config.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.config.v1.{}", Self::NAME) + "cosmos.tx.config.v1.Config".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.config.v1.Config".into() } } diff --git a/src/prost/cosmos.tx.signing.v1beta1.rs b/src/prost/cosmos.tx.signing.v1beta1.rs index 4685364f..0a203e9c 100644 --- a/src/prost/cosmos.tx.signing.v1beta1.rs +++ b/src/prost/cosmos.tx.signing.v1beta1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// SignatureDescriptors wraps multiple SignatureDescriptor's. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -10,7 +11,10 @@ impl ::prost::Name for SignatureDescriptors { const NAME: &'static str = "SignatureDescriptors"; const PACKAGE: &'static str = "cosmos.tx.signing.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.signing.v1beta1.{}", Self::NAME) + "cosmos.tx.signing.v1beta1.SignatureDescriptors".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.signing.v1beta1.SignatureDescriptors".into() } } /// SignatureDescriptor is a convenience type which represents the full data for @@ -60,9 +64,10 @@ pub mod signature_descriptor { const NAME: &'static str = "Single"; const PACKAGE: &'static str = "cosmos.tx.signing.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "cosmos.tx.signing.v1beta1.SignatureDescriptor.Data.{}", Self::NAME - ) + "cosmos.tx.signing.v1beta1.SignatureDescriptor.Data.Single".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.signing.v1beta1.SignatureDescriptor.Data.Single".into() } } /// Multi is the signature data for a multisig public key @@ -82,9 +87,10 @@ pub mod signature_descriptor { const NAME: &'static str = "Multi"; const PACKAGE: &'static str = "cosmos.tx.signing.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "cosmos.tx.signing.v1beta1.SignatureDescriptor.Data.{}", Self::NAME - ) + "cosmos.tx.signing.v1beta1.SignatureDescriptor.Data.Multi".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.signing.v1beta1.SignatureDescriptor.Data.Multi".into() } } /// sum is the oneof that specifies whether this represents single or multi-signature data @@ -103,9 +109,10 @@ pub mod signature_descriptor { const NAME: &'static str = "Data"; const PACKAGE: &'static str = "cosmos.tx.signing.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "cosmos.tx.signing.v1beta1.SignatureDescriptor.{}", Self::NAME - ) + "cosmos.tx.signing.v1beta1.SignatureDescriptor.Data".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.signing.v1beta1.SignatureDescriptor.Data".into() } } } @@ -113,7 +120,10 @@ impl ::prost::Name for SignatureDescriptor { const NAME: &'static str = "SignatureDescriptor"; const PACKAGE: &'static str = "cosmos.tx.signing.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.signing.v1beta1.{}", Self::NAME) + "cosmos.tx.signing.v1beta1.SignatureDescriptor".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.signing.v1beta1.SignatureDescriptor".into() } } /// SignMode represents a signing mode with its own security guarantees. diff --git a/src/prost/cosmos.tx.v1beta1.rs b/src/prost/cosmos.tx.v1beta1.rs index af111bae..1d16a55c 100644 --- a/src/prost/cosmos.tx.v1beta1.rs +++ b/src/prost/cosmos.tx.v1beta1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// Tx is the standard type used for broadcasting transactions. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -19,7 +20,10 @@ impl ::prost::Name for Tx { const NAME: &'static str = "Tx"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.Tx".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.Tx".into() } } /// TxRaw is a variant of Tx that pins the signer's exact binary representation @@ -48,7 +52,10 @@ impl ::prost::Name for TxRaw { const NAME: &'static str = "TxRaw"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.TxRaw".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.TxRaw".into() } } /// SignDoc is the type used for generating sign bytes for SIGN_MODE_DIRECT. @@ -76,7 +83,10 @@ impl ::prost::Name for SignDoc { const NAME: &'static str = "SignDoc"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.SignDoc".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.SignDoc".into() } } /// SignDocDirectAux is the type used for generating sign bytes for @@ -117,7 +127,10 @@ impl ::prost::Name for SignDocDirectAux { const NAME: &'static str = "SignDocDirectAux"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.SignDocDirectAux".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.SignDocDirectAux".into() } } /// TxBody is the body of a transaction that all signers sign over. @@ -161,7 +174,10 @@ impl ::prost::Name for TxBody { const NAME: &'static str = "TxBody"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.TxBody".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.TxBody".into() } } /// AuthInfo describes the fee and signer modes that are used to sign a @@ -194,7 +210,10 @@ impl ::prost::Name for AuthInfo { const NAME: &'static str = "AuthInfo"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.AuthInfo".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.AuthInfo".into() } } /// SignerInfo describes the public key and signing mode of a single top-level @@ -221,7 +240,10 @@ impl ::prost::Name for SignerInfo { const NAME: &'static str = "SignerInfo"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.SignerInfo".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.SignerInfo".into() } } /// ModeInfo describes the signing mode of a single or nested multisig signer. @@ -249,7 +271,10 @@ pub mod mode_info { const NAME: &'static str = "Single"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.ModeInfo.{}", Self::NAME) + "cosmos.tx.v1beta1.ModeInfo.Single".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.ModeInfo.Single".into() } } /// Multi is the mode info for a multisig public key @@ -270,7 +295,10 @@ pub mod mode_info { const NAME: &'static str = "Multi"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.ModeInfo.{}", Self::NAME) + "cosmos.tx.v1beta1.ModeInfo.Multi".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.ModeInfo.Multi".into() } } /// sum is the oneof that specifies whether this represents a single or nested @@ -290,7 +318,10 @@ impl ::prost::Name for ModeInfo { const NAME: &'static str = "ModeInfo"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.ModeInfo".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.ModeInfo".into() } } /// Fee includes the amount of coins paid in fees and the maximum @@ -321,7 +352,10 @@ impl ::prost::Name for Fee { const NAME: &'static str = "Fee"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.Fee".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.Fee".into() } } /// Tip is the tip used for meta-transactions. @@ -341,7 +375,10 @@ impl ::prost::Name for Tip { const NAME: &'static str = "Tip"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.Tip".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.Tip".into() } } /// AuxSignerData is the intermediary format that an auxiliary signer (e.g. a @@ -374,7 +411,10 @@ impl ::prost::Name for AuxSignerData { const NAME: &'static str = "AuxSignerData"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.AuxSignerData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.AuxSignerData".into() } } /// GetTxsEventRequest is the request type for the Service.TxsByEvents @@ -406,7 +446,10 @@ impl ::prost::Name for GetTxsEventRequest { const NAME: &'static str = "GetTxsEventRequest"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.GetTxsEventRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.GetTxsEventRequest".into() } } /// GetTxsEventResponse is the response type for the Service.TxsByEvents @@ -437,7 +480,10 @@ impl ::prost::Name for GetTxsEventResponse { const NAME: &'static str = "GetTxsEventResponse"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.GetTxsEventResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.GetTxsEventResponse".into() } } /// BroadcastTxRequest is the request type for the Service.BroadcastTxRequest @@ -455,7 +501,10 @@ impl ::prost::Name for BroadcastTxRequest { const NAME: &'static str = "BroadcastTxRequest"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.BroadcastTxRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.BroadcastTxRequest".into() } } /// BroadcastTxResponse is the response type for the @@ -473,7 +522,10 @@ impl ::prost::Name for BroadcastTxResponse { const NAME: &'static str = "BroadcastTxResponse"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.BroadcastTxResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.BroadcastTxResponse".into() } } /// SimulateRequest is the request type for the Service.Simulate @@ -496,7 +548,10 @@ impl ::prost::Name for SimulateRequest { const NAME: &'static str = "SimulateRequest"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.SimulateRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.SimulateRequest".into() } } /// SimulateResponse is the response type for the @@ -515,7 +570,10 @@ impl ::prost::Name for SimulateResponse { const NAME: &'static str = "SimulateResponse"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.SimulateResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.SimulateResponse".into() } } /// GetTxRequest is the request type for the Service.GetTx @@ -531,7 +589,10 @@ impl ::prost::Name for GetTxRequest { const NAME: &'static str = "GetTxRequest"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.GetTxRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.GetTxRequest".into() } } /// GetTxResponse is the response type for the Service.GetTx method. @@ -551,7 +612,10 @@ impl ::prost::Name for GetTxResponse { const NAME: &'static str = "GetTxResponse"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.GetTxResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.GetTxResponse".into() } } /// GetBlockWithTxsRequest is the request type for the Service.GetBlockWithTxs @@ -574,7 +638,10 @@ impl ::prost::Name for GetBlockWithTxsRequest { const NAME: &'static str = "GetBlockWithTxsRequest"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.GetBlockWithTxsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.GetBlockWithTxsRequest".into() } } /// GetBlockWithTxsResponse is the response type for the Service.GetBlockWithTxs method. @@ -600,7 +667,10 @@ impl ::prost::Name for GetBlockWithTxsResponse { const NAME: &'static str = "GetBlockWithTxsResponse"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.GetBlockWithTxsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.GetBlockWithTxsResponse".into() } } /// TxDecodeRequest is the request type for the Service.TxDecode @@ -618,7 +688,10 @@ impl ::prost::Name for TxDecodeRequest { const NAME: &'static str = "TxDecodeRequest"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.TxDecodeRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.TxDecodeRequest".into() } } /// TxDecodeResponse is the response type for the @@ -636,7 +709,10 @@ impl ::prost::Name for TxDecodeResponse { const NAME: &'static str = "TxDecodeResponse"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.TxDecodeResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.TxDecodeResponse".into() } } /// TxEncodeRequest is the request type for the Service.TxEncode @@ -654,7 +730,10 @@ impl ::prost::Name for TxEncodeRequest { const NAME: &'static str = "TxEncodeRequest"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.TxEncodeRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.TxEncodeRequest".into() } } /// TxEncodeResponse is the response type for the @@ -672,7 +751,10 @@ impl ::prost::Name for TxEncodeResponse { const NAME: &'static str = "TxEncodeResponse"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.TxEncodeResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.TxEncodeResponse".into() } } /// TxEncodeAminoRequest is the request type for the Service.TxEncodeAmino @@ -689,7 +771,10 @@ impl ::prost::Name for TxEncodeAminoRequest { const NAME: &'static str = "TxEncodeAminoRequest"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.TxEncodeAminoRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.TxEncodeAminoRequest".into() } } /// TxEncodeAminoResponse is the response type for the Service.TxEncodeAmino @@ -706,7 +791,10 @@ impl ::prost::Name for TxEncodeAminoResponse { const NAME: &'static str = "TxEncodeAminoResponse"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.TxEncodeAminoResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.TxEncodeAminoResponse".into() } } /// TxDecodeAminoRequest is the request type for the Service.TxDecodeAmino @@ -723,7 +811,10 @@ impl ::prost::Name for TxDecodeAminoRequest { const NAME: &'static str = "TxDecodeAminoRequest"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.TxDecodeAminoRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.TxDecodeAminoRequest".into() } } /// TxDecodeAminoResponse is the response type for the Service.TxDecodeAmino @@ -740,7 +831,10 @@ impl ::prost::Name for TxDecodeAminoResponse { const NAME: &'static str = "TxDecodeAminoResponse"; const PACKAGE: &'static str = "cosmos.tx.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.tx.v1beta1.{}", Self::NAME) + "cosmos.tx.v1beta1.TxDecodeAminoResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.tx.v1beta1.TxDecodeAminoResponse".into() } } /// OrderBy defines the sorting order diff --git a/src/prost/cosmos.upgrade.module.v1.rs b/src/prost/cosmos.upgrade.module.v1.rs index 198df468..f2db33dd 100644 --- a/src/prost/cosmos.upgrade.module.v1.rs +++ b/src/prost/cosmos.upgrade.module.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// Module is the config object of the upgrade module. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -10,6 +11,9 @@ impl ::prost::Name for Module { const NAME: &'static str = "Module"; const PACKAGE: &'static str = "cosmos.upgrade.module.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.upgrade.module.v1.{}", Self::NAME) + "cosmos.upgrade.module.v1.Module".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.upgrade.module.v1.Module".into() } } diff --git a/src/prost/cosmos.upgrade.v1beta1.rs b/src/prost/cosmos.upgrade.v1beta1.rs index 70d5de72..cf8a8825 100644 --- a/src/prost/cosmos.upgrade.v1beta1.rs +++ b/src/prost/cosmos.upgrade.v1beta1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// Plan specifies information about a planned upgrade and when it should occur. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -37,7 +38,10 @@ impl ::prost::Name for Plan { const NAME: &'static str = "Plan"; const PACKAGE: &'static str = "cosmos.upgrade.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.upgrade.v1beta1.{}", Self::NAME) + "cosmos.upgrade.v1beta1.Plan".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.upgrade.v1beta1.Plan".into() } } /// SoftwareUpgradeProposal is a gov Content type for initiating a software @@ -61,7 +65,10 @@ impl ::prost::Name for SoftwareUpgradeProposal { const NAME: &'static str = "SoftwareUpgradeProposal"; const PACKAGE: &'static str = "cosmos.upgrade.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.upgrade.v1beta1.{}", Self::NAME) + "cosmos.upgrade.v1beta1.SoftwareUpgradeProposal".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.upgrade.v1beta1.SoftwareUpgradeProposal".into() } } /// CancelSoftwareUpgradeProposal is a gov Content type for cancelling a software @@ -82,7 +89,10 @@ impl ::prost::Name for CancelSoftwareUpgradeProposal { const NAME: &'static str = "CancelSoftwareUpgradeProposal"; const PACKAGE: &'static str = "cosmos.upgrade.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.upgrade.v1beta1.{}", Self::NAME) + "cosmos.upgrade.v1beta1.CancelSoftwareUpgradeProposal".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.upgrade.v1beta1.CancelSoftwareUpgradeProposal".into() } } /// ModuleVersion specifies a module and its consensus version. @@ -102,7 +112,10 @@ impl ::prost::Name for ModuleVersion { const NAME: &'static str = "ModuleVersion"; const PACKAGE: &'static str = "cosmos.upgrade.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.upgrade.v1beta1.{}", Self::NAME) + "cosmos.upgrade.v1beta1.ModuleVersion".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.upgrade.v1beta1.ModuleVersion".into() } } /// MsgSoftwareUpgrade is the Msg/SoftwareUpgrade request type. @@ -122,7 +135,10 @@ impl ::prost::Name for MsgSoftwareUpgrade { const NAME: &'static str = "MsgSoftwareUpgrade"; const PACKAGE: &'static str = "cosmos.upgrade.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.upgrade.v1beta1.{}", Self::NAME) + "cosmos.upgrade.v1beta1.MsgSoftwareUpgrade".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.upgrade.v1beta1.MsgSoftwareUpgrade".into() } } /// MsgSoftwareUpgradeResponse is the Msg/SoftwareUpgrade response type. @@ -135,7 +151,10 @@ impl ::prost::Name for MsgSoftwareUpgradeResponse { const NAME: &'static str = "MsgSoftwareUpgradeResponse"; const PACKAGE: &'static str = "cosmos.upgrade.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.upgrade.v1beta1.{}", Self::NAME) + "cosmos.upgrade.v1beta1.MsgSoftwareUpgradeResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.upgrade.v1beta1.MsgSoftwareUpgradeResponse".into() } } /// MsgCancelUpgrade is the Msg/CancelUpgrade request type. @@ -152,7 +171,10 @@ impl ::prost::Name for MsgCancelUpgrade { const NAME: &'static str = "MsgCancelUpgrade"; const PACKAGE: &'static str = "cosmos.upgrade.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.upgrade.v1beta1.{}", Self::NAME) + "cosmos.upgrade.v1beta1.MsgCancelUpgrade".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.upgrade.v1beta1.MsgCancelUpgrade".into() } } /// MsgCancelUpgradeResponse is the Msg/CancelUpgrade response type. @@ -165,7 +187,10 @@ impl ::prost::Name for MsgCancelUpgradeResponse { const NAME: &'static str = "MsgCancelUpgradeResponse"; const PACKAGE: &'static str = "cosmos.upgrade.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.upgrade.v1beta1.{}", Self::NAME) + "cosmos.upgrade.v1beta1.MsgCancelUpgradeResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.upgrade.v1beta1.MsgCancelUpgradeResponse".into() } } /// Generated client implementations. @@ -552,7 +577,10 @@ impl ::prost::Name for QueryCurrentPlanRequest { const NAME: &'static str = "QueryCurrentPlanRequest"; const PACKAGE: &'static str = "cosmos.upgrade.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.upgrade.v1beta1.{}", Self::NAME) + "cosmos.upgrade.v1beta1.QueryCurrentPlanRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.upgrade.v1beta1.QueryCurrentPlanRequest".into() } } /// QueryCurrentPlanResponse is the response type for the Query/CurrentPlan RPC @@ -568,7 +596,10 @@ impl ::prost::Name for QueryCurrentPlanResponse { const NAME: &'static str = "QueryCurrentPlanResponse"; const PACKAGE: &'static str = "cosmos.upgrade.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.upgrade.v1beta1.{}", Self::NAME) + "cosmos.upgrade.v1beta1.QueryCurrentPlanResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.upgrade.v1beta1.QueryCurrentPlanResponse".into() } } /// QueryCurrentPlanRequest is the request type for the Query/AppliedPlan RPC @@ -584,7 +615,10 @@ impl ::prost::Name for QueryAppliedPlanRequest { const NAME: &'static str = "QueryAppliedPlanRequest"; const PACKAGE: &'static str = "cosmos.upgrade.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.upgrade.v1beta1.{}", Self::NAME) + "cosmos.upgrade.v1beta1.QueryAppliedPlanRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.upgrade.v1beta1.QueryAppliedPlanRequest".into() } } /// QueryAppliedPlanResponse is the response type for the Query/AppliedPlan RPC @@ -600,7 +634,10 @@ impl ::prost::Name for QueryAppliedPlanResponse { const NAME: &'static str = "QueryAppliedPlanResponse"; const PACKAGE: &'static str = "cosmos.upgrade.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.upgrade.v1beta1.{}", Self::NAME) + "cosmos.upgrade.v1beta1.QueryAppliedPlanResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.upgrade.v1beta1.QueryAppliedPlanResponse".into() } } /// QueryUpgradedConsensusStateRequest is the request type for the Query/UpgradedConsensusState @@ -617,7 +654,10 @@ impl ::prost::Name for QueryUpgradedConsensusStateRequest { const NAME: &'static str = "QueryUpgradedConsensusStateRequest"; const PACKAGE: &'static str = "cosmos.upgrade.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.upgrade.v1beta1.{}", Self::NAME) + "cosmos.upgrade.v1beta1.QueryUpgradedConsensusStateRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.upgrade.v1beta1.QueryUpgradedConsensusStateRequest".into() } } /// QueryUpgradedConsensusStateResponse is the response type for the Query/UpgradedConsensusState @@ -633,7 +673,10 @@ impl ::prost::Name for QueryUpgradedConsensusStateResponse { const NAME: &'static str = "QueryUpgradedConsensusStateResponse"; const PACKAGE: &'static str = "cosmos.upgrade.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.upgrade.v1beta1.{}", Self::NAME) + "cosmos.upgrade.v1beta1.QueryUpgradedConsensusStateResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.upgrade.v1beta1.QueryUpgradedConsensusStateResponse".into() } } /// QueryModuleVersionsRequest is the request type for the Query/ModuleVersions @@ -653,7 +696,10 @@ impl ::prost::Name for QueryModuleVersionsRequest { const NAME: &'static str = "QueryModuleVersionsRequest"; const PACKAGE: &'static str = "cosmos.upgrade.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.upgrade.v1beta1.{}", Self::NAME) + "cosmos.upgrade.v1beta1.QueryModuleVersionsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.upgrade.v1beta1.QueryModuleVersionsRequest".into() } } /// QueryModuleVersionsResponse is the response type for the Query/ModuleVersions @@ -671,7 +717,10 @@ impl ::prost::Name for QueryModuleVersionsResponse { const NAME: &'static str = "QueryModuleVersionsResponse"; const PACKAGE: &'static str = "cosmos.upgrade.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.upgrade.v1beta1.{}", Self::NAME) + "cosmos.upgrade.v1beta1.QueryModuleVersionsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.upgrade.v1beta1.QueryModuleVersionsResponse".into() } } /// QueryAuthorityRequest is the request type for Query/Authority @@ -684,7 +733,10 @@ impl ::prost::Name for QueryAuthorityRequest { const NAME: &'static str = "QueryAuthorityRequest"; const PACKAGE: &'static str = "cosmos.upgrade.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.upgrade.v1beta1.{}", Self::NAME) + "cosmos.upgrade.v1beta1.QueryAuthorityRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.upgrade.v1beta1.QueryAuthorityRequest".into() } } /// QueryAuthorityResponse is the response type for Query/Authority @@ -700,7 +752,10 @@ impl ::prost::Name for QueryAuthorityResponse { const NAME: &'static str = "QueryAuthorityResponse"; const PACKAGE: &'static str = "cosmos.upgrade.v1beta1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos.upgrade.v1beta1.{}", Self::NAME) + "cosmos.upgrade.v1beta1.QueryAuthorityResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos.upgrade.v1beta1.QueryAuthorityResponse".into() } } /// Generated client implementations. diff --git a/src/prost/cosmos_proto.rs b/src/prost/cosmos_proto.rs index 053c6d52..e45172e7 100644 --- a/src/prost/cosmos_proto.rs +++ b/src/prost/cosmos_proto.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// InterfaceDescriptor describes an interface type to be used with /// accepts_interface and implements_interface and declared by declare_interface. #[allow(clippy::derive_partial_eq_without_eq)] @@ -18,7 +19,10 @@ impl ::prost::Name for InterfaceDescriptor { const NAME: &'static str = "InterfaceDescriptor"; const PACKAGE: &'static str = "cosmos_proto"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos_proto.{}", Self::NAME) + "cosmos_proto.InterfaceDescriptor".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos_proto.InterfaceDescriptor".into() } } /// ScalarDescriptor describes an scalar type to be used with @@ -53,7 +57,10 @@ impl ::prost::Name for ScalarDescriptor { const NAME: &'static str = "ScalarDescriptor"; const PACKAGE: &'static str = "cosmos_proto"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("cosmos_proto.{}", Self::NAME) + "cosmos_proto.ScalarDescriptor".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/cosmos_proto.ScalarDescriptor".into() } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] diff --git a/src/prost/google.api.rs b/src/prost/google.api.rs index 5aa04075..1e50e6f6 100644 --- a/src/prost/google.api.rs +++ b/src/prost/google.api.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// Defines the HTTP configuration for an API service. It contains a list of /// [HttpRule][google.api.HttpRule], each specifying the mapping of an RPC method /// to one or more HTTP REST API methods. @@ -22,10 +23,13 @@ impl ::prost::Name for Http { const NAME: &'static str = "Http"; const PACKAGE: &'static str = "google.api"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.api.{}", Self::NAME) + "google.api.Http".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.api.Http".into() } } -/// # gRPC Transcoding +/// gRPC Transcoding /// /// gRPC Transcoding is a feature for mapping between a gRPC method and one or /// more HTTP REST endpoints. It allows developers to build a single API service @@ -66,9 +70,8 @@ impl ::prost::Name for Http { /// /// This enables an HTTP REST to gRPC mapping as below: /// -/// HTTP | gRPC -/// -----|----- -/// `GET /v1/messages/123456` | `GetMessage(name: "messages/123456")` +/// - HTTP: `GET /v1/messages/123456` +/// - gRPC: `GetMessage(name: "messages/123456")` /// /// Any fields in the request message which are not bound by the path template /// automatically become HTTP query parameters if there is no HTTP request body. @@ -92,11 +95,9 @@ impl ::prost::Name for Http { /// /// This enables a HTTP JSON to RPC mapping as below: /// -/// HTTP | gRPC -/// -----|----- -/// `GET /v1/messages/123456?revision=2&sub.subfield=foo` | -/// `GetMessage(message_id: "123456" revision: 2 sub: SubMessage(subfield: -/// "foo"))` +/// - HTTP: `GET /v1/messages/123456?revision=2&sub.subfield=foo` +/// - gRPC: `GetMessage(message_id: "123456" revision: 2 sub: +/// SubMessage(subfield: "foo"))` /// /// Note that fields which are mapped to URL query parameters must have a /// primitive type or a repeated primitive type or a non-repeated message type. @@ -126,10 +127,8 @@ impl ::prost::Name for Http { /// representation of the JSON in the request body is determined by /// protos JSON encoding: /// -/// HTTP | gRPC -/// -----|----- -/// `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: -/// "123456" message { text: "Hi!" })` +/// - HTTP: `PATCH /v1/messages/123456 { "text": "Hi!" }` +/// - gRPC: `UpdateMessage(message_id: "123456" message { text: "Hi!" })` /// /// The special name `*` can be used in the body mapping to define that /// every field not bound by the path template should be mapped to the @@ -152,10 +151,8 @@ impl ::prost::Name for Http { /// /// The following HTTP JSON to RPC mapping is enabled: /// -/// HTTP | gRPC -/// -----|----- -/// `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: -/// "123456" text: "Hi!")` +/// - HTTP: `PATCH /v1/messages/123456 { "text": "Hi!" }` +/// - gRPC: `UpdateMessage(message_id: "123456" text: "Hi!")` /// /// Note that when using `*` in the body mapping, it is not possible to /// have HTTP parameters, as all fields not bound by the path end in @@ -183,13 +180,13 @@ impl ::prost::Name for Http { /// /// This enables the following two alternative HTTP JSON to RPC mappings: /// -/// HTTP | gRPC -/// -----|----- -/// `GET /v1/messages/123456` | `GetMessage(message_id: "123456")` -/// `GET /v1/users/me/messages/123456` | `GetMessage(user_id: "me" message_id: -/// "123456")` +/// - HTTP: `GET /v1/messages/123456` +/// - gRPC: `GetMessage(message_id: "123456")` +/// +/// - HTTP: `GET /v1/users/me/messages/123456` +/// - gRPC: `GetMessage(user_id: "me" message_id: "123456")` /// -/// ## Rules for HTTP mapping +/// Rules for HTTP mapping /// /// 1. Leaf request fields (recursive expansion nested messages in the request /// message) are classified into three categories: @@ -208,7 +205,7 @@ impl ::prost::Name for Http { /// request body, all /// fields are passed via URL path and URL query parameters. /// -/// ### Path template syntax +/// Path template syntax /// /// Template = "/" Segments \[ Verb \] ; /// Segments = Segment { "/" Segment } ; @@ -247,7 +244,7 @@ impl ::prost::Name for Http { /// Document]() as /// `{+var}`. /// -/// ## Using gRPC API Service Configuration +/// Using gRPC API Service Configuration /// /// gRPC API Service Configuration (service config) is a configuration language /// for configuring a gRPC service to become a user-facing product. The @@ -262,15 +259,14 @@ impl ::prost::Name for Http { /// specified in the service config will override any matching transcoding /// configuration in the proto. /// -/// Example: +/// The following example selects a gRPC method and applies an `HttpRule` to it: /// /// http: /// rules: -/// # Selects a gRPC method and applies HttpRule to it. /// - selector: example.v1.Messaging.GetMessage /// get: /v1/messages/{message_id}/{sub.subfield} /// -/// ## Special notes +/// Special notes /// /// When gRPC Transcoding is used to map a gRPC to JSON REST endpoints, the /// proto to JSON conversion must follow the [proto3 @@ -369,7 +365,10 @@ impl ::prost::Name for HttpRule { const NAME: &'static str = "HttpRule"; const PACKAGE: &'static str = "google.api"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.api.{}", Self::NAME) + "google.api.HttpRule".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.api.HttpRule".into() } } /// A custom pattern is used for defining custom HTTP verb. @@ -387,6 +386,9 @@ impl ::prost::Name for CustomHttpPattern { const NAME: &'static str = "CustomHttpPattern"; const PACKAGE: &'static str = "google.api"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.api.{}", Self::NAME) + "google.api.CustomHttpPattern".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.api.CustomHttpPattern".into() } } diff --git a/src/prost/google.protobuf.rs b/src/prost/google.protobuf.rs index 83971a08..4822b53e 100644 --- a/src/prost/google.protobuf.rs +++ b/src/prost/google.protobuf.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// `Any` contains an arbitrary serialized protocol buffer message along with a /// URL that describes the type of the serialized message. /// @@ -131,7 +132,10 @@ impl ::prost::Name for Any { const NAME: &'static str = "Any"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.Any".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.Any".into() } } /// The protocol compiler can output a FileDescriptorSet containing the .proto @@ -146,7 +150,10 @@ impl ::prost::Name for FileDescriptorSet { const NAME: &'static str = "FileDescriptorSet"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.FileDescriptorSet".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.FileDescriptorSet".into() } } /// Describes a complete .proto file. @@ -200,7 +207,10 @@ impl ::prost::Name for FileDescriptorProto { const NAME: &'static str = "FileDescriptorProto"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.FileDescriptorProto".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.FileDescriptorProto".into() } } /// Describes a message type. @@ -248,7 +258,10 @@ pub mod descriptor_proto { const NAME: &'static str = "ExtensionRange"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.DescriptorProto.{}", Self::NAME) + "google.protobuf.DescriptorProto.ExtensionRange".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.DescriptorProto.ExtensionRange".into() } } /// Range of reserved tag numbers. Reserved tag numbers may not be used by @@ -268,7 +281,10 @@ pub mod descriptor_proto { const NAME: &'static str = "ReservedRange"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.DescriptorProto.{}", Self::NAME) + "google.protobuf.DescriptorProto.ReservedRange".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.DescriptorProto.ReservedRange".into() } } } @@ -276,7 +292,10 @@ impl ::prost::Name for DescriptorProto { const NAME: &'static str = "DescriptorProto"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.DescriptorProto".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.DescriptorProto".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -335,9 +354,10 @@ pub mod extension_range_options { const NAME: &'static str = "Declaration"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "google.protobuf.ExtensionRangeOptions.{}", Self::NAME - ) + "google.protobuf.ExtensionRangeOptions.Declaration".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.ExtensionRangeOptions.Declaration".into() } } /// The verification state of the extension range. @@ -383,7 +403,10 @@ impl ::prost::Name for ExtensionRangeOptions { const NAME: &'static str = "ExtensionRangeOptions"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.ExtensionRangeOptions".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.ExtensionRangeOptions".into() } } /// Describes a field within a message. @@ -602,7 +625,10 @@ impl ::prost::Name for FieldDescriptorProto { const NAME: &'static str = "FieldDescriptorProto"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.FieldDescriptorProto".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.FieldDescriptorProto".into() } } /// Describes a oneof. @@ -618,7 +644,10 @@ impl ::prost::Name for OneofDescriptorProto { const NAME: &'static str = "OneofDescriptorProto"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.OneofDescriptorProto".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.OneofDescriptorProto".into() } } /// Describes an enum type. @@ -665,7 +694,10 @@ pub mod enum_descriptor_proto { const NAME: &'static str = "EnumReservedRange"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.EnumDescriptorProto.{}", Self::NAME) + "google.protobuf.EnumDescriptorProto.EnumReservedRange".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.EnumDescriptorProto.EnumReservedRange".into() } } } @@ -673,7 +705,10 @@ impl ::prost::Name for EnumDescriptorProto { const NAME: &'static str = "EnumDescriptorProto"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.EnumDescriptorProto".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.EnumDescriptorProto".into() } } /// Describes a value within an enum. @@ -691,7 +726,10 @@ impl ::prost::Name for EnumValueDescriptorProto { const NAME: &'static str = "EnumValueDescriptorProto"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.EnumValueDescriptorProto".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.EnumValueDescriptorProto".into() } } /// Describes a service. @@ -709,7 +747,10 @@ impl ::prost::Name for ServiceDescriptorProto { const NAME: &'static str = "ServiceDescriptorProto"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.ServiceDescriptorProto".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.ServiceDescriptorProto".into() } } /// Describes a method of a service. @@ -737,7 +778,10 @@ impl ::prost::Name for MethodDescriptorProto { const NAME: &'static str = "MethodDescriptorProto"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.MethodDescriptorProto".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.MethodDescriptorProto".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -912,7 +956,10 @@ impl ::prost::Name for FileOptions { const NAME: &'static str = "FileOptions"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.FileOptions".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.FileOptions".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -996,7 +1043,10 @@ impl ::prost::Name for MessageOptions { const NAME: &'static str = "MessageOptions"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.MessageOptions".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.MessageOptions".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1119,37 +1169,10 @@ pub mod field_options { const NAME: &'static str = "EditionDefault"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.FieldOptions.{}", Self::NAME) + "google.protobuf.FieldOptions.EditionDefault".into() } - } - /// Information about the support window of a feature. - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct FeatureSupport { - /// The edition that this feature was first available in. In editions - /// earlier than this one, the default assigned to EDITION_LEGACY will be - /// used, and proto files will not be able to override it. - #[prost(enumeration = "super::Edition", optional, tag = "1")] - pub edition_introduced: ::core::option::Option, - /// The edition this feature becomes deprecated in. Using this after this - /// edition may trigger warnings. - #[prost(enumeration = "super::Edition", optional, tag = "2")] - pub edition_deprecated: ::core::option::Option, - /// The deprecation warning text if this feature is used after the edition it - /// was marked deprecated in. - #[prost(string, optional, tag = "3")] - pub deprecation_warning: ::core::option::Option<::prost::alloc::string::String>, - /// The edition this feature is no longer available in. In editions after - /// this one, the last default assigned will be used, and proto files will - /// not be able to override it. - #[prost(enumeration = "super::Edition", optional, tag = "4")] - pub edition_removed: ::core::option::Option, - } - impl ::prost::Name for FeatureSupport { - const NAME: &'static str = "FeatureSupport"; - const PACKAGE: &'static str = "google.protobuf"; - fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.FieldOptions.{}", Self::NAME) + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.FieldOptions.EditionDefault".into() } } /// Information about the support window of a feature. @@ -1386,7 +1409,10 @@ impl ::prost::Name for FieldOptions { const NAME: &'static str = "FieldOptions"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.FieldOptions".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.FieldOptions".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1403,7 +1429,10 @@ impl ::prost::Name for OneofOptions { const NAME: &'static str = "OneofOptions"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.OneofOptions".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.OneofOptions".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1439,7 +1468,10 @@ impl ::prost::Name for EnumOptions { const NAME: &'static str = "EnumOptions"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.EnumOptions".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.EnumOptions".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1470,7 +1502,10 @@ impl ::prost::Name for EnumValueOptions { const NAME: &'static str = "EnumValueOptions"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.EnumValueOptions".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.EnumValueOptions".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1493,7 +1528,10 @@ impl ::prost::Name for ServiceOptions { const NAME: &'static str = "ServiceOptions"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.ServiceOptions".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.ServiceOptions".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1570,7 +1608,10 @@ impl ::prost::Name for MethodOptions { const NAME: &'static str = "MethodOptions"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.MethodOptions".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.MethodOptions".into() } } /// A message representing a option the parser does not recognize. This only @@ -1618,7 +1659,10 @@ pub mod uninterpreted_option { const NAME: &'static str = "NamePart"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.UninterpretedOption.{}", Self::NAME) + "google.protobuf.UninterpretedOption.NamePart".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.UninterpretedOption.NamePart".into() } } } @@ -1626,7 +1670,10 @@ impl ::prost::Name for UninterpretedOption { const NAME: &'static str = "UninterpretedOption"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.UninterpretedOption".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.UninterpretedOption".into() } } /// TODO Enums in C++ gencode (and potentially other languages) are @@ -1895,7 +1942,10 @@ impl ::prost::Name for FeatureSet { const NAME: &'static str = "FeatureSet"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.FeatureSet".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.FeatureSet".into() } } /// A compiled specification for the defaults of a set of features. These @@ -1940,7 +1990,10 @@ pub mod feature_set_defaults { const NAME: &'static str = "FeatureSetEditionDefault"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.FeatureSetDefaults.{}", Self::NAME) + "google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault".into() } } } @@ -1948,7 +2001,10 @@ impl ::prost::Name for FeatureSetDefaults { const NAME: &'static str = "FeatureSetDefaults"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.FeatureSetDefaults".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.FeatureSetDefaults".into() } } /// Encapsulates information about the original source file from which a @@ -2099,7 +2155,10 @@ pub mod source_code_info { const NAME: &'static str = "Location"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.SourceCodeInfo.{}", Self::NAME) + "google.protobuf.SourceCodeInfo.Location".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.SourceCodeInfo.Location".into() } } } @@ -2107,7 +2166,10 @@ impl ::prost::Name for SourceCodeInfo { const NAME: &'static str = "SourceCodeInfo"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.SourceCodeInfo".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.SourceCodeInfo".into() } } /// Describes the relationship between generated code and its original source @@ -2196,7 +2258,10 @@ pub mod generated_code_info { const NAME: &'static str = "Annotation"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.GeneratedCodeInfo.{}", Self::NAME) + "google.protobuf.GeneratedCodeInfo.Annotation".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.GeneratedCodeInfo.Annotation".into() } } } @@ -2204,7 +2269,10 @@ impl ::prost::Name for GeneratedCodeInfo { const NAME: &'static str = "GeneratedCodeInfo"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.GeneratedCodeInfo".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.GeneratedCodeInfo".into() } } /// The full set of known editions. @@ -2388,7 +2456,10 @@ impl ::prost::Name for Timestamp { const NAME: &'static str = "Timestamp"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.Timestamp".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.Timestamp".into() } } /// A Duration represents a signed, fixed-length span of time represented @@ -2472,6 +2543,9 @@ impl ::prost::Name for Duration { const NAME: &'static str = "Duration"; const PACKAGE: &'static str = "google.protobuf"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("google.protobuf.{}", Self::NAME) + "google.protobuf.Duration".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/google.protobuf.Duration".into() } } diff --git a/src/prost/ibc.applications.fee.v1.rs b/src/prost/ibc.applications.fee.v1.rs index 327a8da4..6a199dfb 100644 --- a/src/prost/ibc.applications.fee.v1.rs +++ b/src/prost/ibc.applications.fee.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// Fee defines the ICS29 receive, acknowledgement and timeout fees #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -22,7 +23,10 @@ impl ::prost::Name for Fee { const NAME: &'static str = "Fee"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.Fee".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.Fee".into() } } /// PacketFee contains ICS29 relayer fees, refund address and optional list of permitted relayers @@ -43,7 +47,10 @@ impl ::prost::Name for PacketFee { const NAME: &'static str = "PacketFee"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.PacketFee".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.PacketFee".into() } } /// PacketFees contains a list of type PacketFee @@ -58,7 +65,10 @@ impl ::prost::Name for PacketFees { const NAME: &'static str = "PacketFees"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.PacketFees".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.PacketFees".into() } } /// IdentifiedPacketFees contains a list of type PacketFee and associated PacketId @@ -78,7 +88,10 @@ impl ::prost::Name for IdentifiedPacketFees { const NAME: &'static str = "IdentifiedPacketFees"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.IdentifiedPacketFees".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.IdentifiedPacketFees".into() } } /// MsgRegisterPayee defines the request type for the RegisterPayee rpc @@ -102,7 +115,10 @@ impl ::prost::Name for MsgRegisterPayee { const NAME: &'static str = "MsgRegisterPayee"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.MsgRegisterPayee".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.MsgRegisterPayee".into() } } /// MsgRegisterPayeeResponse defines the response type for the RegisterPayee rpc @@ -113,7 +129,10 @@ impl ::prost::Name for MsgRegisterPayeeResponse { const NAME: &'static str = "MsgRegisterPayeeResponse"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.MsgRegisterPayeeResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.MsgRegisterPayeeResponse".into() } } /// MsgRegisterCounterpartyPayee defines the request type for the RegisterCounterpartyPayee rpc @@ -137,7 +156,10 @@ impl ::prost::Name for MsgRegisterCounterpartyPayee { const NAME: &'static str = "MsgRegisterCounterpartyPayee"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.MsgRegisterCounterpartyPayee".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.MsgRegisterCounterpartyPayee".into() } } /// MsgRegisterCounterpartyPayeeResponse defines the response type for the RegisterCounterpartyPayee rpc @@ -148,7 +170,10 @@ impl ::prost::Name for MsgRegisterCounterpartyPayeeResponse { const NAME: &'static str = "MsgRegisterCounterpartyPayeeResponse"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.MsgRegisterCounterpartyPayeeResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.MsgRegisterCounterpartyPayeeResponse".into() } } /// MsgPayPacketFee defines the request type for the PayPacketFee rpc @@ -177,7 +202,10 @@ impl ::prost::Name for MsgPayPacketFee { const NAME: &'static str = "MsgPayPacketFee"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.MsgPayPacketFee".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.MsgPayPacketFee".into() } } /// MsgPayPacketFeeResponse defines the response type for the PayPacketFee rpc @@ -188,7 +216,10 @@ impl ::prost::Name for MsgPayPacketFeeResponse { const NAME: &'static str = "MsgPayPacketFeeResponse"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.MsgPayPacketFeeResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.MsgPayPacketFeeResponse".into() } } /// MsgPayPacketFeeAsync defines the request type for the PayPacketFeeAsync rpc @@ -209,7 +240,10 @@ impl ::prost::Name for MsgPayPacketFeeAsync { const NAME: &'static str = "MsgPayPacketFeeAsync"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.MsgPayPacketFeeAsync".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.MsgPayPacketFeeAsync".into() } } /// MsgPayPacketFeeAsyncResponse defines the response type for the PayPacketFeeAsync rpc @@ -220,7 +254,10 @@ impl ::prost::Name for MsgPayPacketFeeAsyncResponse { const NAME: &'static str = "MsgPayPacketFeeAsyncResponse"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.MsgPayPacketFeeAsyncResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.MsgPayPacketFeeAsyncResponse".into() } } /// Generated client implementations. @@ -796,7 +833,10 @@ impl ::prost::Name for IncentivizedAcknowledgement { const NAME: &'static str = "IncentivizedAcknowledgement"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.IncentivizedAcknowledgement".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.IncentivizedAcknowledgement".into() } } /// GenesisState defines the ICS29 fee middleware genesis state @@ -825,7 +865,10 @@ impl ::prost::Name for GenesisState { const NAME: &'static str = "GenesisState"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.GenesisState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.GenesisState".into() } } /// FeeEnabledChannel contains the PortID & ChannelID for a fee enabled channel @@ -843,7 +886,10 @@ impl ::prost::Name for FeeEnabledChannel { const NAME: &'static str = "FeeEnabledChannel"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.FeeEnabledChannel".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.FeeEnabledChannel".into() } } /// RegisteredPayee contains the relayer address and payee address for a specific channel @@ -864,7 +910,10 @@ impl ::prost::Name for RegisteredPayee { const NAME: &'static str = "RegisteredPayee"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.RegisteredPayee".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.RegisteredPayee".into() } } /// RegisteredCounterpartyPayee contains the relayer address and counterparty payee address for a specific channel (used @@ -886,7 +935,10 @@ impl ::prost::Name for RegisteredCounterpartyPayee { const NAME: &'static str = "RegisteredCounterpartyPayee"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.RegisteredCounterpartyPayee".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.RegisteredCounterpartyPayee".into() } } /// ForwardRelayerAddress contains the forward relayer address and PacketId used for async acknowledgements @@ -906,7 +958,10 @@ impl ::prost::Name for ForwardRelayerAddress { const NAME: &'static str = "ForwardRelayerAddress"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.ForwardRelayerAddress".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.ForwardRelayerAddress".into() } } /// QueryIncentivizedPacketsRequest defines the request type for the IncentivizedPackets rpc @@ -926,7 +981,10 @@ impl ::prost::Name for QueryIncentivizedPacketsRequest { const NAME: &'static str = "QueryIncentivizedPacketsRequest"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.QueryIncentivizedPacketsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.QueryIncentivizedPacketsRequest".into() } } /// QueryIncentivizedPacketsResponse defines the response type for the IncentivizedPackets rpc @@ -946,7 +1004,10 @@ impl ::prost::Name for QueryIncentivizedPacketsResponse { const NAME: &'static str = "QueryIncentivizedPacketsResponse"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.QueryIncentivizedPacketsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.QueryIncentivizedPacketsResponse".into() } } /// QueryIncentivizedPacketRequest defines the request type for the IncentivizedPacket rpc @@ -966,7 +1027,10 @@ impl ::prost::Name for QueryIncentivizedPacketRequest { const NAME: &'static str = "QueryIncentivizedPacketRequest"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.QueryIncentivizedPacketRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.QueryIncentivizedPacketRequest".into() } } /// QueryIncentivizedPacketsResponse defines the response type for the IncentivizedPacket rpc @@ -981,7 +1045,10 @@ impl ::prost::Name for QueryIncentivizedPacketResponse { const NAME: &'static str = "QueryIncentivizedPacketResponse"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.QueryIncentivizedPacketResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.QueryIncentivizedPacketResponse".into() } } /// QueryIncentivizedPacketsForChannelRequest defines the request type for querying for all incentivized packets @@ -1006,7 +1073,10 @@ impl ::prost::Name for QueryIncentivizedPacketsForChannelRequest { const NAME: &'static str = "QueryIncentivizedPacketsForChannelRequest"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.QueryIncentivizedPacketsForChannelRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.QueryIncentivizedPacketsForChannelRequest".into() } } /// QueryIncentivizedPacketsResponse defines the response type for the incentivized packets RPC @@ -1026,7 +1096,10 @@ impl ::prost::Name for QueryIncentivizedPacketsForChannelResponse { const NAME: &'static str = "QueryIncentivizedPacketsForChannelResponse"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.QueryIncentivizedPacketsForChannelResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.QueryIncentivizedPacketsForChannelResponse".into() } } /// QueryTotalRecvFeesRequest defines the request type for the TotalRecvFees rpc @@ -1043,7 +1116,10 @@ impl ::prost::Name for QueryTotalRecvFeesRequest { const NAME: &'static str = "QueryTotalRecvFeesRequest"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.QueryTotalRecvFeesRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.QueryTotalRecvFeesRequest".into() } } /// QueryTotalRecvFeesResponse defines the response type for the TotalRecvFees rpc @@ -1060,7 +1136,10 @@ impl ::prost::Name for QueryTotalRecvFeesResponse { const NAME: &'static str = "QueryTotalRecvFeesResponse"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.QueryTotalRecvFeesResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.QueryTotalRecvFeesResponse".into() } } /// QueryTotalAckFeesRequest defines the request type for the TotalAckFees rpc @@ -1077,7 +1156,10 @@ impl ::prost::Name for QueryTotalAckFeesRequest { const NAME: &'static str = "QueryTotalAckFeesRequest"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.QueryTotalAckFeesRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.QueryTotalAckFeesRequest".into() } } /// QueryTotalAckFeesResponse defines the response type for the TotalAckFees rpc @@ -1094,7 +1176,10 @@ impl ::prost::Name for QueryTotalAckFeesResponse { const NAME: &'static str = "QueryTotalAckFeesResponse"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.QueryTotalAckFeesResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.QueryTotalAckFeesResponse".into() } } /// QueryTotalTimeoutFeesRequest defines the request type for the TotalTimeoutFees rpc @@ -1111,7 +1196,10 @@ impl ::prost::Name for QueryTotalTimeoutFeesRequest { const NAME: &'static str = "QueryTotalTimeoutFeesRequest"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.QueryTotalTimeoutFeesRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.QueryTotalTimeoutFeesRequest".into() } } /// QueryTotalTimeoutFeesResponse defines the response type for the TotalTimeoutFees rpc @@ -1128,7 +1216,10 @@ impl ::prost::Name for QueryTotalTimeoutFeesResponse { const NAME: &'static str = "QueryTotalTimeoutFeesResponse"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.QueryTotalTimeoutFeesResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.QueryTotalTimeoutFeesResponse".into() } } /// QueryPayeeRequest defines the request type for the Payee rpc @@ -1146,7 +1237,10 @@ impl ::prost::Name for QueryPayeeRequest { const NAME: &'static str = "QueryPayeeRequest"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.QueryPayeeRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.QueryPayeeRequest".into() } } /// QueryPayeeResponse defines the response type for the Payee rpc @@ -1161,7 +1255,10 @@ impl ::prost::Name for QueryPayeeResponse { const NAME: &'static str = "QueryPayeeResponse"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.QueryPayeeResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.QueryPayeeResponse".into() } } /// QueryCounterpartyPayeeRequest defines the request type for the CounterpartyPayee rpc @@ -1179,7 +1276,10 @@ impl ::prost::Name for QueryCounterpartyPayeeRequest { const NAME: &'static str = "QueryCounterpartyPayeeRequest"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.QueryCounterpartyPayeeRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.QueryCounterpartyPayeeRequest".into() } } /// QueryCounterpartyPayeeResponse defines the response type for the CounterpartyPayee rpc @@ -1194,7 +1294,10 @@ impl ::prost::Name for QueryCounterpartyPayeeResponse { const NAME: &'static str = "QueryCounterpartyPayeeResponse"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.QueryCounterpartyPayeeResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.QueryCounterpartyPayeeResponse".into() } } /// QueryFeeEnabledChannelsRequest defines the request type for the FeeEnabledChannels rpc @@ -1214,7 +1317,10 @@ impl ::prost::Name for QueryFeeEnabledChannelsRequest { const NAME: &'static str = "QueryFeeEnabledChannelsRequest"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.QueryFeeEnabledChannelsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.QueryFeeEnabledChannelsRequest".into() } } /// QueryFeeEnabledChannelsResponse defines the response type for the FeeEnabledChannels rpc @@ -1234,7 +1340,10 @@ impl ::prost::Name for QueryFeeEnabledChannelsResponse { const NAME: &'static str = "QueryFeeEnabledChannelsResponse"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.QueryFeeEnabledChannelsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.QueryFeeEnabledChannelsResponse".into() } } /// QueryFeeEnabledChannelRequest defines the request type for the FeeEnabledChannel rpc @@ -1252,7 +1361,10 @@ impl ::prost::Name for QueryFeeEnabledChannelRequest { const NAME: &'static str = "QueryFeeEnabledChannelRequest"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.QueryFeeEnabledChannelRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.QueryFeeEnabledChannelRequest".into() } } /// QueryFeeEnabledChannelResponse defines the response type for the FeeEnabledChannel rpc @@ -1267,7 +1379,10 @@ impl ::prost::Name for QueryFeeEnabledChannelResponse { const NAME: &'static str = "QueryFeeEnabledChannelResponse"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.QueryFeeEnabledChannelResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.QueryFeeEnabledChannelResponse".into() } } /// Generated client implementations. @@ -2328,6 +2443,9 @@ impl ::prost::Name for Metadata { const NAME: &'static str = "Metadata"; const PACKAGE: &'static str = "ibc.applications.fee.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.fee.v1.{}", Self::NAME) + "ibc.applications.fee.v1.Metadata".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.fee.v1.Metadata".into() } } diff --git a/src/prost/ibc.applications.interchain_accounts.controller.v1.rs b/src/prost/ibc.applications.interchain_accounts.controller.v1.rs index 1f51295c..fe6a3f9e 100644 --- a/src/prost/ibc.applications.interchain_accounts.controller.v1.rs +++ b/src/prost/ibc.applications.interchain_accounts.controller.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// Params defines the set of on-chain interchain accounts parameters. /// The following parameters may be used to disable the controller submodule. #[allow(clippy::derive_partial_eq_without_eq)] @@ -11,9 +12,10 @@ impl ::prost::Name for Params { const NAME: &'static str = "Params"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.controller.v1.{}", Self::NAME - ) + "ibc.applications.interchain_accounts.controller.v1.Params".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.controller.v1.Params".into() } } /// MsgRegisterInterchainAccount defines the payload for Msg/RegisterAccount @@ -36,9 +38,12 @@ impl ::prost::Name for MsgRegisterInterchainAccount { const NAME: &'static str = "MsgRegisterInterchainAccount"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.controller.v1.{}", Self::NAME - ) + "ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccount" + .into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccount" + .into() } } /// MsgRegisterInterchainAccountResponse defines the response for Msg/RegisterAccount @@ -54,9 +59,12 @@ impl ::prost::Name for MsgRegisterInterchainAccountResponse { const NAME: &'static str = "MsgRegisterInterchainAccountResponse"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.controller.v1.{}", Self::NAME - ) + "ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccountResponse" + .into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccountResponse" + .into() } } /// MsgSendTx defines the payload for Msg/SendTx @@ -80,9 +88,10 @@ impl ::prost::Name for MsgSendTx { const NAME: &'static str = "MsgSendTx"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.controller.v1.{}", Self::NAME - ) + "ibc.applications.interchain_accounts.controller.v1.MsgSendTx".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.controller.v1.MsgSendTx".into() } } /// MsgSendTxResponse defines the response for MsgSendTx @@ -96,9 +105,10 @@ impl ::prost::Name for MsgSendTxResponse { const NAME: &'static str = "MsgSendTxResponse"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.controller.v1.{}", Self::NAME - ) + "ibc.applications.interchain_accounts.controller.v1.MsgSendTxResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.controller.v1.MsgSendTxResponse".into() } } /// MsgUpdateParams defines the payload for Msg/UpdateParams @@ -118,9 +128,10 @@ impl ::prost::Name for MsgUpdateParams { const NAME: &'static str = "MsgUpdateParams"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.controller.v1.{}", Self::NAME - ) + "ibc.applications.interchain_accounts.controller.v1.MsgUpdateParams".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.controller.v1.MsgUpdateParams".into() } } /// MsgUpdateParamsResponse defines the response for Msg/UpdateParams @@ -131,9 +142,12 @@ impl ::prost::Name for MsgUpdateParamsResponse { const NAME: &'static str = "MsgUpdateParamsResponse"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.controller.v1.{}", Self::NAME - ) + "ibc.applications.interchain_accounts.controller.v1.MsgUpdateParamsResponse" + .into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.controller.v1.MsgUpdateParamsResponse" + .into() } } /// Generated client implementations. @@ -607,9 +621,12 @@ impl ::prost::Name for QueryInterchainAccountRequest { const NAME: &'static str = "QueryInterchainAccountRequest"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.controller.v1.{}", Self::NAME - ) + "ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountRequest" + .into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountRequest" + .into() } } /// QueryInterchainAccountResponse the response type for the Query/InterchainAccount RPC method. @@ -623,9 +640,12 @@ impl ::prost::Name for QueryInterchainAccountResponse { const NAME: &'static str = "QueryInterchainAccountResponse"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.controller.v1.{}", Self::NAME - ) + "ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountResponse" + .into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountResponse" + .into() } } /// QueryParamsRequest is the request type for the Query/Params RPC method. @@ -636,9 +656,10 @@ impl ::prost::Name for QueryParamsRequest { const NAME: &'static str = "QueryParamsRequest"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.controller.v1.{}", Self::NAME - ) + "ibc.applications.interchain_accounts.controller.v1.QueryParamsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.controller.v1.QueryParamsRequest".into() } } /// QueryParamsResponse is the response type for the Query/Params RPC method. @@ -653,9 +674,10 @@ impl ::prost::Name for QueryParamsResponse { const NAME: &'static str = "QueryParamsResponse"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.controller.v1.{}", Self::NAME - ) + "ibc.applications.interchain_accounts.controller.v1.QueryParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.controller.v1.QueryParamsResponse".into() } } /// Generated client implementations. diff --git a/src/prost/ibc.applications.interchain_accounts.genesis.v1.rs b/src/prost/ibc.applications.interchain_accounts.genesis.v1.rs index 10b5ab8c..3ea8e3a5 100644 --- a/src/prost/ibc.applications.interchain_accounts.genesis.v1.rs +++ b/src/prost/ibc.applications.interchain_accounts.genesis.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// GenesisState defines the interchain accounts genesis state #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -11,9 +12,10 @@ impl ::prost::Name for GenesisState { const NAME: &'static str = "GenesisState"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.genesis.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.genesis.v1.{}", Self::NAME - ) + "ibc.applications.interchain_accounts.genesis.v1.GenesisState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.genesis.v1.GenesisState".into() } } /// ControllerGenesisState defines the interchain accounts controller genesis state @@ -33,9 +35,10 @@ impl ::prost::Name for ControllerGenesisState { const NAME: &'static str = "ControllerGenesisState"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.genesis.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.genesis.v1.{}", Self::NAME - ) + "ibc.applications.interchain_accounts.genesis.v1.ControllerGenesisState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.genesis.v1.ControllerGenesisState".into() } } /// HostGenesisState defines the interchain accounts host genesis state @@ -55,9 +58,10 @@ impl ::prost::Name for HostGenesisState { const NAME: &'static str = "HostGenesisState"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.genesis.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.genesis.v1.{}", Self::NAME - ) + "ibc.applications.interchain_accounts.genesis.v1.HostGenesisState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.genesis.v1.HostGenesisState".into() } } /// ActiveChannel contains a connection ID, port ID and associated active channel ID, as well as a boolean flag to @@ -78,9 +82,10 @@ impl ::prost::Name for ActiveChannel { const NAME: &'static str = "ActiveChannel"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.genesis.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.genesis.v1.{}", Self::NAME - ) + "ibc.applications.interchain_accounts.genesis.v1.ActiveChannel".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.genesis.v1.ActiveChannel".into() } } /// RegisteredInterchainAccount contains a connection ID, port ID and associated interchain account address @@ -98,8 +103,11 @@ impl ::prost::Name for RegisteredInterchainAccount { const NAME: &'static str = "RegisteredInterchainAccount"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.genesis.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.genesis.v1.{}", Self::NAME - ) + "ibc.applications.interchain_accounts.genesis.v1.RegisteredInterchainAccount" + .into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.genesis.v1.RegisteredInterchainAccount" + .into() } } diff --git a/src/prost/ibc.applications.interchain_accounts.host.v1.rs b/src/prost/ibc.applications.interchain_accounts.host.v1.rs index 666f516d..b5b61d42 100644 --- a/src/prost/ibc.applications.interchain_accounts.host.v1.rs +++ b/src/prost/ibc.applications.interchain_accounts.host.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// Params defines the set of on-chain interchain accounts parameters. /// The following parameters may be used to disable the host submodule. #[allow(clippy::derive_partial_eq_without_eq)] @@ -14,9 +15,10 @@ impl ::prost::Name for Params { const NAME: &'static str = "Params"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.host.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.host.v1.{}", Self::NAME - ) + "ibc.applications.interchain_accounts.host.v1.Params".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.host.v1.Params".into() } } /// MsgUpdateParams defines the payload for Msg/UpdateParams @@ -36,9 +38,10 @@ impl ::prost::Name for MsgUpdateParams { const NAME: &'static str = "MsgUpdateParams"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.host.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.host.v1.{}", Self::NAME - ) + "ibc.applications.interchain_accounts.host.v1.MsgUpdateParams".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.host.v1.MsgUpdateParams".into() } } /// MsgUpdateParamsResponse defines the response for Msg/UpdateParams @@ -49,9 +52,10 @@ impl ::prost::Name for MsgUpdateParamsResponse { const NAME: &'static str = "MsgUpdateParamsResponse"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.host.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.host.v1.{}", Self::NAME - ) + "ibc.applications.interchain_accounts.host.v1.MsgUpdateParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.host.v1.MsgUpdateParamsResponse".into() } } /// Generated client implementations. @@ -353,9 +357,10 @@ impl ::prost::Name for QueryParamsRequest { const NAME: &'static str = "QueryParamsRequest"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.host.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.host.v1.{}", Self::NAME - ) + "ibc.applications.interchain_accounts.host.v1.QueryParamsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.host.v1.QueryParamsRequest".into() } } /// QueryParamsResponse is the response type for the Query/Params RPC method. @@ -370,9 +375,10 @@ impl ::prost::Name for QueryParamsResponse { const NAME: &'static str = "QueryParamsResponse"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.host.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.host.v1.{}", Self::NAME - ) + "ibc.applications.interchain_accounts.host.v1.QueryParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.host.v1.QueryParamsResponse".into() } } /// Generated client implementations. diff --git a/src/prost/ibc.applications.interchain_accounts.v1.rs b/src/prost/ibc.applications.interchain_accounts.v1.rs index 045606e3..ae774eb9 100644 --- a/src/prost/ibc.applications.interchain_accounts.v1.rs +++ b/src/prost/ibc.applications.interchain_accounts.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// An InterchainAccount is defined as a BaseAccount & the address of the account owner on the controller chain #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -13,7 +14,10 @@ impl ::prost::Name for InterchainAccount { const NAME: &'static str = "InterchainAccount"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.interchain_accounts.v1.{}", Self::NAME) + "ibc.applications.interchain_accounts.v1.InterchainAccount".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.v1.InterchainAccount".into() } } /// InterchainAccountPacketData is comprised of a raw transaction, type of transaction and optional memo field. @@ -31,7 +35,10 @@ impl ::prost::Name for InterchainAccountPacketData { const NAME: &'static str = "InterchainAccountPacketData"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.interchain_accounts.v1.{}", Self::NAME) + "ibc.applications.interchain_accounts.v1.InterchainAccountPacketData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.v1.InterchainAccountPacketData".into() } } /// CosmosTx contains a list of sdk.Msg's. It should be used when sending transactions to an SDK host chain. @@ -47,7 +54,10 @@ impl ::prost::Name for CosmosTx { const NAME: &'static str = "CosmosTx"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.interchain_accounts.v1.{}", Self::NAME) + "ibc.applications.interchain_accounts.v1.CosmosTx".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.v1.CosmosTx".into() } } /// Type defines a classification of message issued from a controller chain to its associated interchain accounts @@ -109,6 +119,9 @@ impl ::prost::Name for Metadata { const NAME: &'static str = "Metadata"; const PACKAGE: &'static str = "ibc.applications.interchain_accounts.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.interchain_accounts.v1.{}", Self::NAME) + "ibc.applications.interchain_accounts.v1.Metadata".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.v1.Metadata".into() } } diff --git a/src/prost/ibc.applications.nft_transfer.v1.rs b/src/prost/ibc.applications.nft_transfer.v1.rs index cd47e590..12a22efe 100644 --- a/src/prost/ibc.applications.nft_transfer.v1.rs +++ b/src/prost/ibc.applications.nft_transfer.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// ClassTrace contains the base classID for ICS721 non-fungible tokens and the /// source tracing information path. #[allow(clippy::derive_partial_eq_without_eq)] @@ -15,7 +16,10 @@ impl ::prost::Name for ClassTrace { const NAME: &'static str = "ClassTrace"; const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + "ibc.applications.nft_transfer.v1.ClassTrace".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.nft_transfer.v1.ClassTrace".into() } } /// Params defines the set of IBC nft-transfer parameters. @@ -37,7 +41,10 @@ impl ::prost::Name for Params { const NAME: &'static str = "Params"; const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + "ibc.applications.nft_transfer.v1.Params".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.nft_transfer.v1.Params".into() } } /// MsgTransfer defines a msg to transfer non fungible tokens between @@ -82,7 +89,10 @@ impl ::prost::Name for MsgTransfer { const NAME: &'static str = "MsgTransfer"; const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + "ibc.applications.nft_transfer.v1.MsgTransfer".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.nft_transfer.v1.MsgTransfer".into() } } /// MsgTransferResponse defines the Msg/Transfer response type. @@ -97,7 +107,10 @@ impl ::prost::Name for MsgTransferResponse { const NAME: &'static str = "MsgTransferResponse"; const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + "ibc.applications.nft_transfer.v1.MsgTransferResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.nft_transfer.v1.MsgTransferResponse".into() } } /// MsgUpdateParams is the Msg/UpdateParams request type. @@ -118,7 +131,10 @@ impl ::prost::Name for MsgUpdateParams { const NAME: &'static str = "MsgUpdateParams"; const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + "ibc.applications.nft_transfer.v1.MsgUpdateParams".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.nft_transfer.v1.MsgUpdateParams".into() } } /// MsgUpdateParamsResponse defines the response structure for executing a @@ -131,7 +147,10 @@ impl ::prost::Name for MsgUpdateParamsResponse { const NAME: &'static str = "MsgUpdateParamsResponse"; const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + "ibc.applications.nft_transfer.v1.MsgUpdateParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.nft_transfer.v1.MsgUpdateParamsResponse".into() } } /// Generated client implementations. @@ -546,7 +565,10 @@ impl ::prost::Name for NonFungibleTokenPacketData { const NAME: &'static str = "NonFungibleTokenPacketData"; const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + "ibc.applications.nft_transfer.v1.NonFungibleTokenPacketData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.nft_transfer.v1.NonFungibleTokenPacketData".into() } } /// QueryClassTraceRequest is the request type for the Query/ClassDenom RPC @@ -563,7 +585,10 @@ impl ::prost::Name for QueryClassTraceRequest { const NAME: &'static str = "QueryClassTraceRequest"; const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + "ibc.applications.nft_transfer.v1.QueryClassTraceRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.nft_transfer.v1.QueryClassTraceRequest".into() } } /// QueryClassTraceResponse is the response type for the Query/ClassDenom RPC @@ -579,7 +604,10 @@ impl ::prost::Name for QueryClassTraceResponse { const NAME: &'static str = "QueryClassTraceResponse"; const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + "ibc.applications.nft_transfer.v1.QueryClassTraceResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.nft_transfer.v1.QueryClassTraceResponse".into() } } /// QueryConnectionsRequest is the request type for the Query/ClassTraces RPC @@ -597,7 +625,10 @@ impl ::prost::Name for QueryClassTracesRequest { const NAME: &'static str = "QueryClassTracesRequest"; const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + "ibc.applications.nft_transfer.v1.QueryClassTracesRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.nft_transfer.v1.QueryClassTracesRequest".into() } } /// QueryClassTracesResponse is the response type for the Query/ClassTraces RPC @@ -618,7 +649,10 @@ impl ::prost::Name for QueryClassTracesResponse { const NAME: &'static str = "QueryClassTracesResponse"; const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + "ibc.applications.nft_transfer.v1.QueryClassTracesResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.nft_transfer.v1.QueryClassTracesResponse".into() } } /// QueryClassHashRequest is the request type for the Query/ClassHash RPC @@ -634,7 +668,10 @@ impl ::prost::Name for QueryClassHashRequest { const NAME: &'static str = "QueryClassHashRequest"; const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + "ibc.applications.nft_transfer.v1.QueryClassHashRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.nft_transfer.v1.QueryClassHashRequest".into() } } /// QueryClassHashResponse is the response type for the Query/ClassHash RPC @@ -650,7 +687,10 @@ impl ::prost::Name for QueryClassHashResponse { const NAME: &'static str = "QueryClassHashResponse"; const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + "ibc.applications.nft_transfer.v1.QueryClassHashResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.nft_transfer.v1.QueryClassHashResponse".into() } } /// QueryEscrowAddressRequest is the request type for the EscrowAddress RPC @@ -669,7 +709,10 @@ impl ::prost::Name for QueryEscrowAddressRequest { const NAME: &'static str = "QueryEscrowAddressRequest"; const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + "ibc.applications.nft_transfer.v1.QueryEscrowAddressRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.nft_transfer.v1.QueryEscrowAddressRequest".into() } } /// QueryEscrowAddressResponse is the response type of the EscrowAddress RPC @@ -685,7 +728,10 @@ impl ::prost::Name for QueryEscrowAddressResponse { const NAME: &'static str = "QueryEscrowAddressResponse"; const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + "ibc.applications.nft_transfer.v1.QueryEscrowAddressResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.nft_transfer.v1.QueryEscrowAddressResponse".into() } } /// QueryParamsRequest is request type for the Query/Params RPC method. @@ -696,7 +742,10 @@ impl ::prost::Name for QueryParamsRequest { const NAME: &'static str = "QueryParamsRequest"; const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + "ibc.applications.nft_transfer.v1.QueryParamsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.nft_transfer.v1.QueryParamsRequest".into() } } /// QueryParamsResponse is response type for the Query/Params RPC method. @@ -711,7 +760,10 @@ impl ::prost::Name for QueryParamsResponse { const NAME: &'static str = "QueryParamsResponse"; const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + "ibc.applications.nft_transfer.v1.QueryParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.nft_transfer.v1.QueryParamsResponse".into() } } /// Generated client implementations. @@ -1355,6 +1407,9 @@ impl ::prost::Name for GenesisState { const NAME: &'static str = "GenesisState"; const PACKAGE: &'static str = "ibc.applications.nft_transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.nft_transfer.v1.{}", Self::NAME) + "ibc.applications.nft_transfer.v1.GenesisState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.nft_transfer.v1.GenesisState".into() } } diff --git a/src/prost/ibc.applications.transfer.v1.rs b/src/prost/ibc.applications.transfer.v1.rs index 842b66ce..98eb521f 100644 --- a/src/prost/ibc.applications.transfer.v1.rs +++ b/src/prost/ibc.applications.transfer.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// DenomTrace contains the base denomination for ICS20 fungible tokens and the /// source tracing information path. #[allow(clippy::derive_partial_eq_without_eq)] @@ -15,7 +16,10 @@ impl ::prost::Name for DenomTrace { const NAME: &'static str = "DenomTrace"; const PACKAGE: &'static str = "ibc.applications.transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.transfer.v1.{}", Self::NAME) + "ibc.applications.transfer.v1.DenomTrace".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.DenomTrace".into() } } /// Params defines the set of IBC transfer parameters. @@ -38,7 +42,10 @@ impl ::prost::Name for Params { const NAME: &'static str = "Params"; const PACKAGE: &'static str = "ibc.applications.transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.transfer.v1.{}", Self::NAME) + "ibc.applications.transfer.v1.Params".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.Params".into() } } /// MsgTransfer defines a msg to transfer fungible tokens (i.e Coins) between @@ -82,7 +89,10 @@ impl ::prost::Name for MsgTransfer { const NAME: &'static str = "MsgTransfer"; const PACKAGE: &'static str = "ibc.applications.transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.transfer.v1.{}", Self::NAME) + "ibc.applications.transfer.v1.MsgTransfer".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.MsgTransfer".into() } } /// MsgTransferResponse defines the Msg/Transfer response type. @@ -97,7 +107,10 @@ impl ::prost::Name for MsgTransferResponse { const NAME: &'static str = "MsgTransferResponse"; const PACKAGE: &'static str = "ibc.applications.transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.transfer.v1.{}", Self::NAME) + "ibc.applications.transfer.v1.MsgTransferResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.MsgTransferResponse".into() } } /// MsgUpdateParams is the Msg/UpdateParams request type. @@ -117,7 +130,10 @@ impl ::prost::Name for MsgUpdateParams { const NAME: &'static str = "MsgUpdateParams"; const PACKAGE: &'static str = "ibc.applications.transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.transfer.v1.{}", Self::NAME) + "ibc.applications.transfer.v1.MsgUpdateParams".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.MsgUpdateParams".into() } } /// MsgUpdateParamsResponse defines the response structure for executing a @@ -129,7 +145,10 @@ impl ::prost::Name for MsgUpdateParamsResponse { const NAME: &'static str = "MsgUpdateParamsResponse"; const PACKAGE: &'static str = "ibc.applications.transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.transfer.v1.{}", Self::NAME) + "ibc.applications.transfer.v1.MsgUpdateParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.MsgUpdateParamsResponse".into() } } /// Generated client implementations. @@ -510,7 +529,10 @@ impl ::prost::Name for QueryDenomTraceRequest { const NAME: &'static str = "QueryDenomTraceRequest"; const PACKAGE: &'static str = "ibc.applications.transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.transfer.v1.{}", Self::NAME) + "ibc.applications.transfer.v1.QueryDenomTraceRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.QueryDenomTraceRequest".into() } } /// QueryDenomTraceResponse is the response type for the Query/DenomTrace RPC @@ -526,7 +548,10 @@ impl ::prost::Name for QueryDenomTraceResponse { const NAME: &'static str = "QueryDenomTraceResponse"; const PACKAGE: &'static str = "ibc.applications.transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.transfer.v1.{}", Self::NAME) + "ibc.applications.transfer.v1.QueryDenomTraceResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.QueryDenomTraceResponse".into() } } /// QueryConnectionsRequest is the request type for the Query/DenomTraces RPC @@ -544,7 +569,10 @@ impl ::prost::Name for QueryDenomTracesRequest { const NAME: &'static str = "QueryDenomTracesRequest"; const PACKAGE: &'static str = "ibc.applications.transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.transfer.v1.{}", Self::NAME) + "ibc.applications.transfer.v1.QueryDenomTracesRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.QueryDenomTracesRequest".into() } } /// QueryConnectionsResponse is the response type for the Query/DenomTraces RPC @@ -565,7 +593,10 @@ impl ::prost::Name for QueryDenomTracesResponse { const NAME: &'static str = "QueryDenomTracesResponse"; const PACKAGE: &'static str = "ibc.applications.transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.transfer.v1.{}", Self::NAME) + "ibc.applications.transfer.v1.QueryDenomTracesResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.QueryDenomTracesResponse".into() } } /// QueryParamsRequest is the request type for the Query/Params RPC method. @@ -576,7 +607,10 @@ impl ::prost::Name for QueryParamsRequest { const NAME: &'static str = "QueryParamsRequest"; const PACKAGE: &'static str = "ibc.applications.transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.transfer.v1.{}", Self::NAME) + "ibc.applications.transfer.v1.QueryParamsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.QueryParamsRequest".into() } } /// QueryParamsResponse is the response type for the Query/Params RPC method. @@ -591,7 +625,10 @@ impl ::prost::Name for QueryParamsResponse { const NAME: &'static str = "QueryParamsResponse"; const PACKAGE: &'static str = "ibc.applications.transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.transfer.v1.{}", Self::NAME) + "ibc.applications.transfer.v1.QueryParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.QueryParamsResponse".into() } } /// QueryDenomHashRequest is the request type for the Query/DenomHash RPC @@ -607,7 +644,10 @@ impl ::prost::Name for QueryDenomHashRequest { const NAME: &'static str = "QueryDenomHashRequest"; const PACKAGE: &'static str = "ibc.applications.transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.transfer.v1.{}", Self::NAME) + "ibc.applications.transfer.v1.QueryDenomHashRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.QueryDenomHashRequest".into() } } /// QueryDenomHashResponse is the response type for the Query/DenomHash RPC @@ -623,7 +663,10 @@ impl ::prost::Name for QueryDenomHashResponse { const NAME: &'static str = "QueryDenomHashResponse"; const PACKAGE: &'static str = "ibc.applications.transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.transfer.v1.{}", Self::NAME) + "ibc.applications.transfer.v1.QueryDenomHashResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.QueryDenomHashResponse".into() } } /// QueryEscrowAddressRequest is the request type for the EscrowAddress RPC method. @@ -641,7 +684,10 @@ impl ::prost::Name for QueryEscrowAddressRequest { const NAME: &'static str = "QueryEscrowAddressRequest"; const PACKAGE: &'static str = "ibc.applications.transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.transfer.v1.{}", Self::NAME) + "ibc.applications.transfer.v1.QueryEscrowAddressRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.QueryEscrowAddressRequest".into() } } /// QueryEscrowAddressResponse is the response type of the EscrowAddress RPC method. @@ -656,7 +702,10 @@ impl ::prost::Name for QueryEscrowAddressResponse { const NAME: &'static str = "QueryEscrowAddressResponse"; const PACKAGE: &'static str = "ibc.applications.transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.transfer.v1.{}", Self::NAME) + "ibc.applications.transfer.v1.QueryEscrowAddressResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.QueryEscrowAddressResponse".into() } } /// QueryTotalEscrowForDenomRequest is the request type for TotalEscrowForDenom RPC method. @@ -670,7 +719,10 @@ impl ::prost::Name for QueryTotalEscrowForDenomRequest { const NAME: &'static str = "QueryTotalEscrowForDenomRequest"; const PACKAGE: &'static str = "ibc.applications.transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.transfer.v1.{}", Self::NAME) + "ibc.applications.transfer.v1.QueryTotalEscrowForDenomRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.QueryTotalEscrowForDenomRequest".into() } } /// QueryTotalEscrowForDenomResponse is the response type for TotalEscrowForDenom RPC method. @@ -686,7 +738,10 @@ impl ::prost::Name for QueryTotalEscrowForDenomResponse { const NAME: &'static str = "QueryTotalEscrowForDenomResponse"; const PACKAGE: &'static str = "ibc.applications.transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.transfer.v1.{}", Self::NAME) + "ibc.applications.transfer.v1.QueryTotalEscrowForDenomResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.QueryTotalEscrowForDenomResponse".into() } } /// Generated client implementations. @@ -1415,7 +1470,10 @@ impl ::prost::Name for Allocation { const NAME: &'static str = "Allocation"; const PACKAGE: &'static str = "ibc.applications.transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.transfer.v1.{}", Self::NAME) + "ibc.applications.transfer.v1.Allocation".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.Allocation".into() } } /// TransferAuthorization allows the grantee to spend up to spend_limit coins from @@ -1431,7 +1489,10 @@ impl ::prost::Name for TransferAuthorization { const NAME: &'static str = "TransferAuthorization"; const PACKAGE: &'static str = "ibc.applications.transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.transfer.v1.{}", Self::NAME) + "ibc.applications.transfer.v1.TransferAuthorization".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.TransferAuthorization".into() } } /// GenesisState defines the ibc-transfer genesis state @@ -1455,6 +1516,9 @@ impl ::prost::Name for GenesisState { const NAME: &'static str = "GenesisState"; const PACKAGE: &'static str = "ibc.applications.transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.transfer.v1.{}", Self::NAME) + "ibc.applications.transfer.v1.GenesisState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.GenesisState".into() } } diff --git a/src/prost/ibc.applications.transfer.v2.rs b/src/prost/ibc.applications.transfer.v2.rs index 33fa7869..a479baef 100644 --- a/src/prost/ibc.applications.transfer.v2.rs +++ b/src/prost/ibc.applications.transfer.v2.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// FungibleTokenPacketData defines a struct for the packet payload /// See FungibleTokenPacketData spec: /// @@ -24,6 +25,9 @@ impl ::prost::Name for FungibleTokenPacketData { const NAME: &'static str = "FungibleTokenPacketData"; const PACKAGE: &'static str = "ibc.applications.transfer.v2"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.applications.transfer.v2.{}", Self::NAME) + "ibc.applications.transfer.v2.FungibleTokenPacketData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v2.FungibleTokenPacketData".into() } } diff --git a/src/prost/ibc.core.channel.v1.rs b/src/prost/ibc.core.channel.v1.rs index 0bec0605..906b0dcd 100644 --- a/src/prost/ibc.core.channel.v1.rs +++ b/src/prost/ibc.core.channel.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// Channel defines pipeline for exactly-once packet delivery between specific /// modules on separate blockchains, which has at least one end capable of /// sending packets and one end capable of receiving packets. @@ -33,7 +34,10 @@ impl ::prost::Name for Channel { const NAME: &'static str = "Channel"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.Channel".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.Channel".into() } } /// IdentifiedChannel defines a channel with additional port and channel @@ -72,7 +76,10 @@ impl ::prost::Name for IdentifiedChannel { const NAME: &'static str = "IdentifiedChannel"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.IdentifiedChannel".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.IdentifiedChannel".into() } } /// Counterparty defines a channel end counterparty @@ -94,7 +101,10 @@ impl ::prost::Name for Counterparty { const NAME: &'static str = "Counterparty"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.Counterparty".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.Counterparty".into() } } /// Packet defines a type that carries data across different chains through IBC @@ -132,7 +142,10 @@ impl ::prost::Name for Packet { const NAME: &'static str = "Packet"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.Packet".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.Packet".into() } } /// PacketState defines the generic type necessary to retrieve and store @@ -159,7 +172,10 @@ impl ::prost::Name for PacketState { const NAME: &'static str = "PacketState"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.PacketState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.PacketState".into() } } /// PacketId is an identifer for a unique Packet @@ -182,7 +198,10 @@ impl ::prost::Name for PacketId { const NAME: &'static str = "PacketId"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.PacketId".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.PacketId".into() } } /// Acknowledgement is the recommended acknowledgement format to be used by @@ -215,7 +234,10 @@ impl ::prost::Name for Acknowledgement { const NAME: &'static str = "Acknowledgement"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.Acknowledgement".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.Acknowledgement".into() } } /// Timeout defines an execution deadline structure for 04-channel handlers. @@ -235,7 +257,10 @@ impl ::prost::Name for Timeout { const NAME: &'static str = "Timeout"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.Timeout".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.Timeout".into() } } /// Params defines the set of IBC channel parameters. @@ -250,7 +275,10 @@ impl ::prost::Name for Params { const NAME: &'static str = "Params"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.Params".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.Params".into() } } /// State defines if a channel is in one of the following states: @@ -371,7 +399,10 @@ impl ::prost::Name for GenesisState { const NAME: &'static str = "GenesisState"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.GenesisState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.GenesisState".into() } } /// PacketSequence defines the genesis type necessary to retrieve and store @@ -390,7 +421,10 @@ impl ::prost::Name for PacketSequence { const NAME: &'static str = "PacketSequence"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.PacketSequence".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.PacketSequence".into() } } /// Upgrade is a verifiable type which contains the relevant information @@ -412,7 +446,10 @@ impl ::prost::Name for Upgrade { const NAME: &'static str = "Upgrade"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.Upgrade".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.Upgrade".into() } } /// UpgradeFields are the fields in a channel end which may be changed @@ -431,7 +468,10 @@ impl ::prost::Name for UpgradeFields { const NAME: &'static str = "UpgradeFields"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.UpgradeFields".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.UpgradeFields".into() } } /// ErrorReceipt defines a type which encapsulates the upgrade sequence and error associated with the @@ -451,7 +491,10 @@ impl ::prost::Name for ErrorReceipt { const NAME: &'static str = "ErrorReceipt"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.ErrorReceipt".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.ErrorReceipt".into() } } /// MsgChannelOpenInit defines an sdk.Msg to initialize a channel handshake. It @@ -470,7 +513,10 @@ impl ::prost::Name for MsgChannelOpenInit { const NAME: &'static str = "MsgChannelOpenInit"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelOpenInit".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelOpenInit".into() } } /// MsgChannelOpenInitResponse defines the Msg/ChannelOpenInit response type. @@ -486,7 +532,10 @@ impl ::prost::Name for MsgChannelOpenInitResponse { const NAME: &'static str = "MsgChannelOpenInitResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelOpenInitResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelOpenInitResponse".into() } } /// MsgChannelOpenInit defines a msg sent by a Relayer to try to open a channel @@ -517,7 +566,10 @@ impl ::prost::Name for MsgChannelOpenTry { const NAME: &'static str = "MsgChannelOpenTry"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelOpenTry".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelOpenTry".into() } } /// MsgChannelOpenTryResponse defines the Msg/ChannelOpenTry response type. @@ -533,7 +585,10 @@ impl ::prost::Name for MsgChannelOpenTryResponse { const NAME: &'static str = "MsgChannelOpenTryResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelOpenTryResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelOpenTryResponse".into() } } /// MsgChannelOpenAck defines a msg sent by a Relayer to Chain A to acknowledge @@ -563,7 +618,10 @@ impl ::prost::Name for MsgChannelOpenAck { const NAME: &'static str = "MsgChannelOpenAck"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelOpenAck".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelOpenAck".into() } } /// MsgChannelOpenAckResponse defines the Msg/ChannelOpenAck response type. @@ -574,7 +632,10 @@ impl ::prost::Name for MsgChannelOpenAckResponse { const NAME: &'static str = "MsgChannelOpenAckResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelOpenAckResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelOpenAckResponse".into() } } /// MsgChannelOpenConfirm defines a msg sent by a Relayer to Chain B to @@ -597,7 +658,10 @@ impl ::prost::Name for MsgChannelOpenConfirm { const NAME: &'static str = "MsgChannelOpenConfirm"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelOpenConfirm".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelOpenConfirm".into() } } /// MsgChannelOpenConfirmResponse defines the Msg/ChannelOpenConfirm response @@ -609,7 +673,10 @@ impl ::prost::Name for MsgChannelOpenConfirmResponse { const NAME: &'static str = "MsgChannelOpenConfirmResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelOpenConfirmResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelOpenConfirmResponse".into() } } /// MsgChannelCloseInit defines a msg sent by a Relayer to Chain A @@ -628,7 +695,10 @@ impl ::prost::Name for MsgChannelCloseInit { const NAME: &'static str = "MsgChannelCloseInit"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelCloseInit".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelCloseInit".into() } } /// MsgChannelCloseInitResponse defines the Msg/ChannelCloseInit response type. @@ -639,7 +709,10 @@ impl ::prost::Name for MsgChannelCloseInitResponse { const NAME: &'static str = "MsgChannelCloseInitResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelCloseInitResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelCloseInitResponse".into() } } /// MsgChannelCloseConfirm defines a msg sent by a Relayer to Chain B @@ -664,7 +737,10 @@ impl ::prost::Name for MsgChannelCloseConfirm { const NAME: &'static str = "MsgChannelCloseConfirm"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelCloseConfirm".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelCloseConfirm".into() } } /// MsgChannelCloseConfirmResponse defines the Msg/ChannelCloseConfirm response @@ -676,7 +752,10 @@ impl ::prost::Name for MsgChannelCloseConfirmResponse { const NAME: &'static str = "MsgChannelCloseConfirmResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelCloseConfirmResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelCloseConfirmResponse".into() } } /// MsgChannelCloseFrozen defines a msg sent by a Relayer to force close @@ -701,19 +780,25 @@ impl ::prost::Name for MsgChannelCloseFrozen { const NAME: &'static str = "MsgChannelCloseFrozen"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelCloseFrozen".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelCloseFrozen".into() } } /// MsgChannelCloseFrozenResponse defines the Msg/ChannelFrozenConfirm response /// type. #[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] pub struct MsgChannelCloseFrozenResponse {} impl ::prost::Name for MsgChannelCloseFrozenResponse { const NAME: &'static str = "MsgChannelCloseFrozenResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelCloseFrozenResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelCloseFrozenResponse".into() } } /// MsgRecvPacket receives incoming IBC packet @@ -733,7 +818,10 @@ impl ::prost::Name for MsgRecvPacket { const NAME: &'static str = "MsgRecvPacket"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgRecvPacket".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgRecvPacket".into() } } /// MsgRecvPacketResponse defines the Msg/RecvPacket response type. @@ -747,7 +835,10 @@ impl ::prost::Name for MsgRecvPacketResponse { const NAME: &'static str = "MsgRecvPacketResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgRecvPacketResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgRecvPacketResponse".into() } } /// MsgTimeout receives timed-out packet @@ -769,7 +860,10 @@ impl ::prost::Name for MsgTimeout { const NAME: &'static str = "MsgTimeout"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgTimeout".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgTimeout".into() } } /// MsgTimeoutResponse defines the Msg/Timeout response type. @@ -783,7 +877,10 @@ impl ::prost::Name for MsgTimeoutResponse { const NAME: &'static str = "MsgTimeoutResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgTimeoutResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgTimeoutResponse".into() } } /// MsgTimeoutOnClose timed-out packet upon counterparty channel closure. @@ -809,7 +906,10 @@ impl ::prost::Name for MsgTimeoutOnClose { const NAME: &'static str = "MsgTimeoutOnClose"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgTimeoutOnClose".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgTimeoutOnClose".into() } } /// MsgTimeoutOnCloseResponse defines the Msg/TimeoutOnClose response type. @@ -823,7 +923,10 @@ impl ::prost::Name for MsgTimeoutOnCloseResponse { const NAME: &'static str = "MsgTimeoutOnCloseResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgTimeoutOnCloseResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgTimeoutOnCloseResponse".into() } } /// MsgAcknowledgement receives incoming IBC acknowledgement @@ -845,7 +948,10 @@ impl ::prost::Name for MsgAcknowledgement { const NAME: &'static str = "MsgAcknowledgement"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgAcknowledgement".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgAcknowledgement".into() } } /// MsgAcknowledgementResponse defines the Msg/Acknowledgement response type. @@ -859,7 +965,10 @@ impl ::prost::Name for MsgAcknowledgementResponse { const NAME: &'static str = "MsgAcknowledgementResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgAcknowledgementResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgAcknowledgementResponse".into() } } /// MsgChannelUpgradeInit defines the request type for the ChannelUpgradeInit rpc @@ -881,7 +990,10 @@ impl ::prost::Name for MsgChannelUpgradeInit { const NAME: &'static str = "MsgChannelUpgradeInit"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelUpgradeInit".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelUpgradeInit".into() } } /// MsgChannelUpgradeInitResponse defines the MsgChannelUpgradeInit response type @@ -897,7 +1009,10 @@ impl ::prost::Name for MsgChannelUpgradeInitResponse { const NAME: &'static str = "MsgChannelUpgradeInitResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelUpgradeInitResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelUpgradeInitResponse".into() } } /// MsgChannelUpgradeTry defines the request type for the ChannelUpgradeTry rpc @@ -929,7 +1044,10 @@ impl ::prost::Name for MsgChannelUpgradeTry { const NAME: &'static str = "MsgChannelUpgradeTry"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelUpgradeTry".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelUpgradeTry".into() } } /// MsgChannelUpgradeTryResponse defines the MsgChannelUpgradeTry response type @@ -947,7 +1065,10 @@ impl ::prost::Name for MsgChannelUpgradeTryResponse { const NAME: &'static str = "MsgChannelUpgradeTryResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelUpgradeTryResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelUpgradeTryResponse".into() } } /// MsgChannelUpgradeAck defines the request type for the ChannelUpgradeAck rpc @@ -973,7 +1094,10 @@ impl ::prost::Name for MsgChannelUpgradeAck { const NAME: &'static str = "MsgChannelUpgradeAck"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelUpgradeAck".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelUpgradeAck".into() } } /// MsgChannelUpgradeAckResponse defines MsgChannelUpgradeAck response type @@ -987,7 +1111,10 @@ impl ::prost::Name for MsgChannelUpgradeAckResponse { const NAME: &'static str = "MsgChannelUpgradeAckResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelUpgradeAckResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelUpgradeAckResponse".into() } } /// MsgChannelUpgradeConfirm defines the request type for the ChannelUpgradeConfirm rpc @@ -1015,7 +1142,10 @@ impl ::prost::Name for MsgChannelUpgradeConfirm { const NAME: &'static str = "MsgChannelUpgradeConfirm"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelUpgradeConfirm".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelUpgradeConfirm".into() } } /// MsgChannelUpgradeConfirmResponse defines MsgChannelUpgradeConfirm response type @@ -1029,7 +1159,10 @@ impl ::prost::Name for MsgChannelUpgradeConfirmResponse { const NAME: &'static str = "MsgChannelUpgradeConfirmResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelUpgradeConfirmResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelUpgradeConfirmResponse".into() } } /// MsgChannelUpgradeOpen defines the request type for the ChannelUpgradeOpen rpc @@ -1055,7 +1188,10 @@ impl ::prost::Name for MsgChannelUpgradeOpen { const NAME: &'static str = "MsgChannelUpgradeOpen"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelUpgradeOpen".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelUpgradeOpen".into() } } /// MsgChannelUpgradeOpenResponse defines the MsgChannelUpgradeOpen response type @@ -1066,7 +1202,10 @@ impl ::prost::Name for MsgChannelUpgradeOpenResponse { const NAME: &'static str = "MsgChannelUpgradeOpenResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelUpgradeOpenResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelUpgradeOpenResponse".into() } } /// MsgChannelUpgradeTimeout defines the request type for the ChannelUpgradeTimeout rpc @@ -1090,7 +1229,10 @@ impl ::prost::Name for MsgChannelUpgradeTimeout { const NAME: &'static str = "MsgChannelUpgradeTimeout"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelUpgradeTimeout".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelUpgradeTimeout".into() } } /// MsgChannelUpgradeTimeoutRepsonse defines the MsgChannelUpgradeTimeout response type @@ -1101,7 +1243,10 @@ impl ::prost::Name for MsgChannelUpgradeTimeoutResponse { const NAME: &'static str = "MsgChannelUpgradeTimeoutResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelUpgradeTimeoutResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelUpgradeTimeoutResponse".into() } } /// MsgChannelUpgradeCancel defines the request type for the ChannelUpgradeCancel rpc @@ -1125,7 +1270,10 @@ impl ::prost::Name for MsgChannelUpgradeCancel { const NAME: &'static str = "MsgChannelUpgradeCancel"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelUpgradeCancel".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelUpgradeCancel".into() } } /// MsgChannelUpgradeCancelResponse defines the MsgChannelUpgradeCancel response type @@ -1136,7 +1284,10 @@ impl ::prost::Name for MsgChannelUpgradeCancelResponse { const NAME: &'static str = "MsgChannelUpgradeCancelResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgChannelUpgradeCancelResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgChannelUpgradeCancelResponse".into() } } /// MsgUpdateParams is the MsgUpdateParams request type. @@ -1156,7 +1307,10 @@ impl ::prost::Name for MsgUpdateParams { const NAME: &'static str = "MsgUpdateParams"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgUpdateParams".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgUpdateParams".into() } } /// MsgUpdateParamsResponse defines the MsgUpdateParams response type. @@ -1167,7 +1321,10 @@ impl ::prost::Name for MsgUpdateParamsResponse { const NAME: &'static str = "MsgUpdateParamsResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgUpdateParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgUpdateParamsResponse".into() } } /// MsgPruneAcknowledgements defines the request type for the PruneAcknowledgements rpc. @@ -1187,7 +1344,10 @@ impl ::prost::Name for MsgPruneAcknowledgements { const NAME: &'static str = "MsgPruneAcknowledgements"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgPruneAcknowledgements".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgPruneAcknowledgements".into() } } /// MsgPruneAcknowledgementsResponse defines the response type for the PruneAcknowledgements rpc. @@ -1205,7 +1365,10 @@ impl ::prost::Name for MsgPruneAcknowledgementsResponse { const NAME: &'static str = "MsgPruneAcknowledgementsResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgPruneAcknowledgementsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgPruneAcknowledgementsResponse".into() } } /// MultihopProof holds the information necessary to prove a multihop message @@ -1223,7 +1386,10 @@ impl ::prost::Name for MultihopProof { const NAME: &'static str = "MultihopProof"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MultihopProof".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MultihopProof".into() } } /// MsgMultihopProofs holds the proof information for each intermediary hop for a multihop message @@ -1241,7 +1407,10 @@ impl ::prost::Name for MsgMultihopProofs { const NAME: &'static str = "MsgMultihopProofs"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.MsgMultihopProofs".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.MsgMultihopProofs".into() } } /// ResponseResultType defines the possible outcomes of the execution of a message @@ -2449,7 +2618,6 @@ pub mod msg_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let inner = inner.0; let method = ChannelCloseFrozenSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) @@ -3086,7 +3254,10 @@ impl ::prost::Name for QueryChannelRequest { const NAME: &'static str = "QueryChannelRequest"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryChannelRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryChannelRequest".into() } } /// QueryChannelResponse is the response type for the Query/Channel RPC method. @@ -3109,7 +3280,10 @@ impl ::prost::Name for QueryChannelResponse { const NAME: &'static str = "QueryChannelResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryChannelResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryChannelResponse".into() } } /// QueryChannelsRequest is the request type for the Query/Channels RPC method @@ -3126,7 +3300,10 @@ impl ::prost::Name for QueryChannelsRequest { const NAME: &'static str = "QueryChannelsRequest"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryChannelsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryChannelsRequest".into() } } /// QueryChannelsResponse is the response type for the Query/Channels RPC method. @@ -3149,7 +3326,10 @@ impl ::prost::Name for QueryChannelsResponse { const NAME: &'static str = "QueryChannelsResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryChannelsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryChannelsResponse".into() } } /// QueryConnectionChannelsRequest is the request type for the @@ -3170,7 +3350,10 @@ impl ::prost::Name for QueryConnectionChannelsRequest { const NAME: &'static str = "QueryConnectionChannelsRequest"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryConnectionChannelsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryConnectionChannelsRequest".into() } } /// QueryConnectionChannelsResponse is the Response type for the @@ -3194,7 +3377,10 @@ impl ::prost::Name for QueryConnectionChannelsResponse { const NAME: &'static str = "QueryConnectionChannelsResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryConnectionChannelsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryConnectionChannelsResponse".into() } } /// QueryChannelClientStateRequest is the request type for the Query/ClientState @@ -3213,7 +3399,10 @@ impl ::prost::Name for QueryChannelClientStateRequest { const NAME: &'static str = "QueryChannelClientStateRequest"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryChannelClientStateRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryChannelClientStateRequest".into() } } /// QueryChannelClientStateResponse is the Response type for the @@ -3237,7 +3426,10 @@ impl ::prost::Name for QueryChannelClientStateResponse { const NAME: &'static str = "QueryChannelClientStateResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryChannelClientStateResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryChannelClientStateResponse".into() } } /// QueryChannelConsensusStateRequest is the request type for the @@ -3262,7 +3454,10 @@ impl ::prost::Name for QueryChannelConsensusStateRequest { const NAME: &'static str = "QueryChannelConsensusStateRequest"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryChannelConsensusStateRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryChannelConsensusStateRequest".into() } } /// QueryChannelClientStateResponse is the Response type for the @@ -3289,7 +3484,10 @@ impl ::prost::Name for QueryChannelConsensusStateResponse { const NAME: &'static str = "QueryChannelConsensusStateResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryChannelConsensusStateResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryChannelConsensusStateResponse".into() } } /// QueryPacketCommitmentRequest is the request type for the @@ -3311,7 +3509,10 @@ impl ::prost::Name for QueryPacketCommitmentRequest { const NAME: &'static str = "QueryPacketCommitmentRequest"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryPacketCommitmentRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryPacketCommitmentRequest".into() } } /// QueryPacketCommitmentResponse defines the client query response for a packet @@ -3334,7 +3535,10 @@ impl ::prost::Name for QueryPacketCommitmentResponse { const NAME: &'static str = "QueryPacketCommitmentResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryPacketCommitmentResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryPacketCommitmentResponse".into() } } /// QueryPacketCommitmentsRequest is the request type for the @@ -3358,7 +3562,10 @@ impl ::prost::Name for QueryPacketCommitmentsRequest { const NAME: &'static str = "QueryPacketCommitmentsRequest"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryPacketCommitmentsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryPacketCommitmentsRequest".into() } } /// QueryPacketCommitmentsResponse is the request type for the @@ -3381,7 +3588,10 @@ impl ::prost::Name for QueryPacketCommitmentsResponse { const NAME: &'static str = "QueryPacketCommitmentsResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryPacketCommitmentsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryPacketCommitmentsResponse".into() } } /// QueryPacketReceiptRequest is the request type for the @@ -3403,7 +3613,10 @@ impl ::prost::Name for QueryPacketReceiptRequest { const NAME: &'static str = "QueryPacketReceiptRequest"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryPacketReceiptRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryPacketReceiptRequest".into() } } /// QueryPacketReceiptResponse defines the client query response for a packet @@ -3426,7 +3639,10 @@ impl ::prost::Name for QueryPacketReceiptResponse { const NAME: &'static str = "QueryPacketReceiptResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryPacketReceiptResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryPacketReceiptResponse".into() } } /// QueryPacketAcknowledgementRequest is the request type for the @@ -3448,7 +3664,10 @@ impl ::prost::Name for QueryPacketAcknowledgementRequest { const NAME: &'static str = "QueryPacketAcknowledgementRequest"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryPacketAcknowledgementRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryPacketAcknowledgementRequest".into() } } /// QueryPacketAcknowledgementResponse defines the client query response for a @@ -3471,7 +3690,10 @@ impl ::prost::Name for QueryPacketAcknowledgementResponse { const NAME: &'static str = "QueryPacketAcknowledgementResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryPacketAcknowledgementResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryPacketAcknowledgementResponse".into() } } /// QueryPacketAcknowledgementsRequest is the request type for the @@ -3498,7 +3720,10 @@ impl ::prost::Name for QueryPacketAcknowledgementsRequest { const NAME: &'static str = "QueryPacketAcknowledgementsRequest"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryPacketAcknowledgementsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryPacketAcknowledgementsRequest".into() } } /// QueryPacketAcknowledgemetsResponse is the request type for the @@ -3521,7 +3746,10 @@ impl ::prost::Name for QueryPacketAcknowledgementsResponse { const NAME: &'static str = "QueryPacketAcknowledgementsResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryPacketAcknowledgementsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryPacketAcknowledgementsResponse".into() } } /// QueryUnreceivedPacketsRequest is the request type for the @@ -3543,7 +3771,10 @@ impl ::prost::Name for QueryUnreceivedPacketsRequest { const NAME: &'static str = "QueryUnreceivedPacketsRequest"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryUnreceivedPacketsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryUnreceivedPacketsRequest".into() } } /// QueryUnreceivedPacketsResponse is the response type for the @@ -3562,7 +3793,10 @@ impl ::prost::Name for QueryUnreceivedPacketsResponse { const NAME: &'static str = "QueryUnreceivedPacketsResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryUnreceivedPacketsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryUnreceivedPacketsResponse".into() } } /// QueryUnreceivedAcks is the request type for the @@ -3584,7 +3818,10 @@ impl ::prost::Name for QueryUnreceivedAcksRequest { const NAME: &'static str = "QueryUnreceivedAcksRequest"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryUnreceivedAcksRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryUnreceivedAcksRequest".into() } } /// QueryUnreceivedAcksResponse is the response type for the @@ -3603,7 +3840,10 @@ impl ::prost::Name for QueryUnreceivedAcksResponse { const NAME: &'static str = "QueryUnreceivedAcksResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryUnreceivedAcksResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryUnreceivedAcksResponse".into() } } /// QueryNextSequenceReceiveRequest is the request type for the @@ -3622,7 +3862,10 @@ impl ::prost::Name for QueryNextSequenceReceiveRequest { const NAME: &'static str = "QueryNextSequenceReceiveRequest"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryNextSequenceReceiveRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryNextSequenceReceiveRequest".into() } } /// QuerySequenceResponse is the response type for the @@ -3644,7 +3887,10 @@ impl ::prost::Name for QueryNextSequenceReceiveResponse { const NAME: &'static str = "QueryNextSequenceReceiveResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryNextSequenceReceiveResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryNextSequenceReceiveResponse".into() } } /// QueryNextSequenceSendRequest is the request type for the @@ -3663,7 +3909,10 @@ impl ::prost::Name for QueryNextSequenceSendRequest { const NAME: &'static str = "QueryNextSequenceSendRequest"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryNextSequenceSendRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryNextSequenceSendRequest".into() } } /// QueryNextSequenceSendResponse is the request type for the @@ -3685,7 +3934,10 @@ impl ::prost::Name for QueryNextSequenceSendResponse { const NAME: &'static str = "QueryNextSequenceSendResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryNextSequenceSendResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryNextSequenceSendResponse".into() } } /// QueryUpgradeErrorRequest is the request type for the Query/QueryUpgradeError RPC method @@ -3701,7 +3953,10 @@ impl ::prost::Name for QueryUpgradeErrorRequest { const NAME: &'static str = "QueryUpgradeErrorRequest"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryUpgradeErrorRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryUpgradeErrorRequest".into() } } /// QueryUpgradeErrorResponse is the response type for the Query/QueryUpgradeError RPC method @@ -3721,7 +3976,10 @@ impl ::prost::Name for QueryUpgradeErrorResponse { const NAME: &'static str = "QueryUpgradeErrorResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryUpgradeErrorResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryUpgradeErrorResponse".into() } } /// QueryUpgradeRequest is the request type for the QueryUpgradeRequest RPC method @@ -3737,7 +3995,10 @@ impl ::prost::Name for QueryUpgradeRequest { const NAME: &'static str = "QueryUpgradeRequest"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryUpgradeRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryUpgradeRequest".into() } } /// QueryUpgradeResponse is the response type for the QueryUpgradeResponse RPC method @@ -3757,7 +4018,10 @@ impl ::prost::Name for QueryUpgradeResponse { const NAME: &'static str = "QueryUpgradeResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryUpgradeResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryUpgradeResponse".into() } } /// QueryChannelParamsRequest is the request type for the Query/ChannelParams RPC method. @@ -3768,7 +4032,10 @@ impl ::prost::Name for QueryChannelParamsRequest { const NAME: &'static str = "QueryChannelParamsRequest"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryChannelParamsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryChannelParamsRequest".into() } } /// QueryChannelParamsResponse is the response type for the Query/ChannelParams RPC method. @@ -3783,7 +4050,10 @@ impl ::prost::Name for QueryChannelParamsResponse { const NAME: &'static str = "QueryChannelParamsResponse"; const PACKAGE: &'static str = "ibc.core.channel.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + "ibc.core.channel.v1.QueryChannelParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.channel.v1.QueryChannelParamsResponse".into() } } /// Generated client implementations. diff --git a/src/prost/ibc.core.client.v1.rs b/src/prost/ibc.core.client.v1.rs index 8fdd9e15..2281a531 100644 --- a/src/prost/ibc.core.client.v1.rs +++ b/src/prost/ibc.core.client.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// IdentifiedClientState defines a client state with an additional client /// identifier field. #[allow(clippy::derive_partial_eq_without_eq)] @@ -16,7 +17,10 @@ impl ::prost::Name for IdentifiedClientState { const NAME: &'static str = "IdentifiedClientState"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.IdentifiedClientState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.IdentifiedClientState".into() } } /// ConsensusStateWithHeight defines a consensus state with an additional height @@ -37,7 +41,10 @@ impl ::prost::Name for ConsensusStateWithHeight { const NAME: &'static str = "ConsensusStateWithHeight"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.ConsensusStateWithHeight".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.ConsensusStateWithHeight".into() } } /// ClientConsensusStates defines all the stored consensus states for a given @@ -56,7 +63,10 @@ impl ::prost::Name for ClientConsensusStates { const NAME: &'static str = "ClientConsensusStates"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.ClientConsensusStates".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.ClientConsensusStates".into() } } /// Height is a monotonically increasing data type @@ -88,7 +98,10 @@ impl ::prost::Name for Height { const NAME: &'static str = "Height"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.Height".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.Height".into() } } /// Params defines the set of IBC light client parameters. @@ -105,7 +118,10 @@ impl ::prost::Name for Params { const NAME: &'static str = "Params"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.Params".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.Params".into() } } /// ClientUpdateProposal is a legacy governance proposal. If it passes, the substitute @@ -135,7 +151,10 @@ impl ::prost::Name for ClientUpdateProposal { const NAME: &'static str = "ClientUpdateProposal"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.ClientUpdateProposal".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.ClientUpdateProposal".into() } } /// UpgradeProposal is a gov Content type for initiating an IBC breaking @@ -168,7 +187,10 @@ impl ::prost::Name for UpgradeProposal { const NAME: &'static str = "UpgradeProposal"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.UpgradeProposal".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.UpgradeProposal".into() } } /// GenesisState defines the ibc client submodule's genesis state. @@ -199,7 +221,10 @@ impl ::prost::Name for GenesisState { const NAME: &'static str = "GenesisState"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.GenesisState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.GenesisState".into() } } /// GenesisMetadata defines the genesis type for metadata that clients may return @@ -218,7 +243,10 @@ impl ::prost::Name for GenesisMetadata { const NAME: &'static str = "GenesisMetadata"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.GenesisMetadata".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.GenesisMetadata".into() } } /// IdentifiedGenesisMetadata has the client metadata with the corresponding @@ -235,7 +263,10 @@ impl ::prost::Name for IdentifiedGenesisMetadata { const NAME: &'static str = "IdentifiedGenesisMetadata"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.IdentifiedGenesisMetadata".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.IdentifiedGenesisMetadata".into() } } /// MsgCreateClient defines a message to create an IBC client @@ -261,7 +292,10 @@ impl ::prost::Name for MsgCreateClient { const NAME: &'static str = "MsgCreateClient"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.MsgCreateClient".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.MsgCreateClient".into() } } /// MsgCreateClientResponse defines the Msg/CreateClient response type. @@ -272,7 +306,10 @@ impl ::prost::Name for MsgCreateClientResponse { const NAME: &'static str = "MsgCreateClientResponse"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.MsgCreateClientResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.MsgCreateClientResponse".into() } } /// MsgUpdateClient defines an sdk.Msg to update a IBC client state using @@ -296,7 +333,10 @@ impl ::prost::Name for MsgUpdateClient { const NAME: &'static str = "MsgUpdateClient"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.MsgUpdateClient".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.MsgUpdateClient".into() } } /// MsgUpdateClientResponse defines the Msg/UpdateClient response type. @@ -307,7 +347,10 @@ impl ::prost::Name for MsgUpdateClientResponse { const NAME: &'static str = "MsgUpdateClientResponse"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.MsgUpdateClientResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.MsgUpdateClientResponse".into() } } /// MsgUpgradeClient defines an sdk.Msg to upgrade an IBC client to a new client @@ -343,7 +386,10 @@ impl ::prost::Name for MsgUpgradeClient { const NAME: &'static str = "MsgUpgradeClient"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.MsgUpgradeClient".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.MsgUpgradeClient".into() } } /// MsgUpgradeClientResponse defines the Msg/UpgradeClient response type. @@ -354,7 +400,10 @@ impl ::prost::Name for MsgUpgradeClientResponse { const NAME: &'static str = "MsgUpgradeClientResponse"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.MsgUpgradeClientResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.MsgUpgradeClientResponse".into() } } /// MsgSubmitMisbehaviour defines an sdk.Msg type that submits Evidence for @@ -379,7 +428,10 @@ impl ::prost::Name for MsgSubmitMisbehaviour { const NAME: &'static str = "MsgSubmitMisbehaviour"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.MsgSubmitMisbehaviour".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.MsgSubmitMisbehaviour".into() } } /// MsgSubmitMisbehaviourResponse defines the Msg/SubmitMisbehaviour response @@ -391,7 +443,10 @@ impl ::prost::Name for MsgSubmitMisbehaviourResponse { const NAME: &'static str = "MsgSubmitMisbehaviourResponse"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.MsgSubmitMisbehaviourResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.MsgSubmitMisbehaviourResponse".into() } } /// MsgRecoverClient defines the message used to recover a frozen or expired client. @@ -413,7 +468,10 @@ impl ::prost::Name for MsgRecoverClient { const NAME: &'static str = "MsgRecoverClient"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.MsgRecoverClient".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.MsgRecoverClient".into() } } /// MsgRecoverClientResponse defines the Msg/RecoverClient response type. @@ -424,7 +482,10 @@ impl ::prost::Name for MsgRecoverClientResponse { const NAME: &'static str = "MsgRecoverClientResponse"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.MsgRecoverClientResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.MsgRecoverClientResponse".into() } } /// MsgIBCSoftwareUpgrade defines the message used to schedule an upgrade of an IBC client using a v1 governance proposal @@ -455,7 +516,10 @@ impl ::prost::Name for MsgIbcSoftwareUpgrade { const NAME: &'static str = "MsgIBCSoftwareUpgrade"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.MsgIBCSoftwareUpgrade".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.MsgIBCSoftwareUpgrade".into() } } /// MsgIBCSoftwareUpgradeResponse defines the Msg/IBCSoftwareUpgrade response type. @@ -466,7 +530,10 @@ impl ::prost::Name for MsgIbcSoftwareUpgradeResponse { const NAME: &'static str = "MsgIBCSoftwareUpgradeResponse"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.MsgIBCSoftwareUpgradeResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.MsgIBCSoftwareUpgradeResponse".into() } } /// MsgUpdateParams defines the sdk.Msg type to update the client parameters. @@ -486,7 +553,10 @@ impl ::prost::Name for MsgUpdateParams { const NAME: &'static str = "MsgUpdateParams"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.MsgUpdateParams".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.MsgUpdateParams".into() } } /// MsgUpdateParamsResponse defines the MsgUpdateParams response type. @@ -497,7 +567,10 @@ impl ::prost::Name for MsgUpdateParamsResponse { const NAME: &'static str = "MsgUpdateParamsResponse"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.MsgUpdateParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.MsgUpdateParamsResponse".into() } } /// Generated client implementations. @@ -1265,7 +1338,10 @@ impl ::prost::Name for QueryClientStateRequest { const NAME: &'static str = "QueryClientStateRequest"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.QueryClientStateRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryClientStateRequest".into() } } /// QueryClientStateResponse is the response type for the Query/ClientState RPC @@ -1290,7 +1366,10 @@ impl ::prost::Name for QueryClientStateResponse { const NAME: &'static str = "QueryClientStateResponse"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.QueryClientStateResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryClientStateResponse".into() } } /// QueryClientStatesRequest is the request type for the Query/ClientStates RPC @@ -1308,7 +1387,10 @@ impl ::prost::Name for QueryClientStatesRequest { const NAME: &'static str = "QueryClientStatesRequest"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.QueryClientStatesRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryClientStatesRequest".into() } } /// QueryClientStatesResponse is the response type for the Query/ClientStates RPC @@ -1329,7 +1411,10 @@ impl ::prost::Name for QueryClientStatesResponse { const NAME: &'static str = "QueryClientStatesResponse"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.QueryClientStatesResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryClientStatesResponse".into() } } /// QueryConsensusStateRequest is the request type for the Query/ConsensusState @@ -1356,7 +1441,10 @@ impl ::prost::Name for QueryConsensusStateRequest { const NAME: &'static str = "QueryConsensusStateRequest"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.QueryConsensusStateRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryConsensusStateRequest".into() } } /// QueryConsensusStateResponse is the response type for the Query/ConsensusState @@ -1380,7 +1468,10 @@ impl ::prost::Name for QueryConsensusStateResponse { const NAME: &'static str = "QueryConsensusStateResponse"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.QueryConsensusStateResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryConsensusStateResponse".into() } } /// QueryConsensusStatesRequest is the request type for the Query/ConsensusStates @@ -1401,7 +1492,10 @@ impl ::prost::Name for QueryConsensusStatesRequest { const NAME: &'static str = "QueryConsensusStatesRequest"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.QueryConsensusStatesRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryConsensusStatesRequest".into() } } /// QueryConsensusStatesResponse is the response type for the @@ -1422,7 +1516,10 @@ impl ::prost::Name for QueryConsensusStatesResponse { const NAME: &'static str = "QueryConsensusStatesResponse"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.QueryConsensusStatesResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryConsensusStatesResponse".into() } } /// QueryNextConsensusStateRequest is the request type for the Query/ConsensusState @@ -1445,13 +1542,16 @@ impl ::prost::Name for QueryNextConsensusStateHeightRequest { const NAME: &'static str = "QueryNextConsensusStateHeightRequest"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.QueryNextConsensusStateHeightRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryNextConsensusStateHeightRequest".into() } } /// QueryNextConsensusStateResponse is the response type for the Query/ConsensusState /// RPC method #[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] pub struct QueryNextConsensusStateHeightResponse { /// minimum consensus state height associated with the client identifier larger /// than the query height @@ -1462,7 +1562,10 @@ impl ::prost::Name for QueryNextConsensusStateHeightResponse { const NAME: &'static str = "QueryNextConsensusStateHeightResponse"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.QueryNextConsensusStateHeightResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryNextConsensusStateHeightResponse".into() } } /// QueryConsensusStateHeightsRequest is the request type for Query/ConsensusStateHeights @@ -1483,7 +1586,10 @@ impl ::prost::Name for QueryConsensusStateHeightsRequest { const NAME: &'static str = "QueryConsensusStateHeightsRequest"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.QueryConsensusStateHeightsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryConsensusStateHeightsRequest".into() } } /// QueryConsensusStateHeightsResponse is the response type for the @@ -1504,7 +1610,10 @@ impl ::prost::Name for QueryConsensusStateHeightsResponse { const NAME: &'static str = "QueryConsensusStateHeightsResponse"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.QueryConsensusStateHeightsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryConsensusStateHeightsResponse".into() } } /// QueryClientStatusRequest is the request type for the Query/ClientStatus RPC @@ -1520,7 +1629,10 @@ impl ::prost::Name for QueryClientStatusRequest { const NAME: &'static str = "QueryClientStatusRequest"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.QueryClientStatusRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryClientStatusRequest".into() } } /// QueryClientStatusResponse is the response type for the Query/ClientStatus RPC @@ -1535,7 +1647,10 @@ impl ::prost::Name for QueryClientStatusResponse { const NAME: &'static str = "QueryClientStatusResponse"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.QueryClientStatusResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryClientStatusResponse".into() } } /// QueryClientParamsRequest is the request type for the Query/ClientParams RPC @@ -1547,7 +1662,10 @@ impl ::prost::Name for QueryClientParamsRequest { const NAME: &'static str = "QueryClientParamsRequest"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.QueryClientParamsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryClientParamsRequest".into() } } /// QueryClientParamsResponse is the response type for the Query/ClientParams RPC @@ -1563,7 +1681,10 @@ impl ::prost::Name for QueryClientParamsResponse { const NAME: &'static str = "QueryClientParamsResponse"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.QueryClientParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryClientParamsResponse".into() } } /// QueryUpgradedClientStateRequest is the request type for the @@ -1575,7 +1696,10 @@ impl ::prost::Name for QueryUpgradedClientStateRequest { const NAME: &'static str = "QueryUpgradedClientStateRequest"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.QueryUpgradedClientStateRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryUpgradedClientStateRequest".into() } } /// QueryUpgradedClientStateResponse is the response type for the @@ -1593,7 +1717,10 @@ impl ::prost::Name for QueryUpgradedClientStateResponse { const NAME: &'static str = "QueryUpgradedClientStateResponse"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.QueryUpgradedClientStateResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryUpgradedClientStateResponse".into() } } /// QueryUpgradedConsensusStateRequest is the request type for the @@ -1605,7 +1732,10 @@ impl ::prost::Name for QueryUpgradedConsensusStateRequest { const NAME: &'static str = "QueryUpgradedConsensusStateRequest"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.QueryUpgradedConsensusStateRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryUpgradedConsensusStateRequest".into() } } /// QueryUpgradedConsensusStateResponse is the response type for the @@ -1623,7 +1753,10 @@ impl ::prost::Name for QueryUpgradedConsensusStateResponse { const NAME: &'static str = "QueryUpgradedConsensusStateResponse"; const PACKAGE: &'static str = "ibc.core.client.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.QueryUpgradedConsensusStateResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryUpgradedConsensusStateResponse".into() } } /// Generated client implementations. @@ -2371,7 +2504,6 @@ pub mod query_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let inner = inner.0; let method = NextConsensusStateHeightSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) diff --git a/src/prost/ibc.core.commitment.v1.rs b/src/prost/ibc.core.commitment.v1.rs index 3045d902..77d2ca9a 100644 --- a/src/prost/ibc.core.commitment.v1.rs +++ b/src/prost/ibc.core.commitment.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// MerkleRoot defines a merkle root hash. /// In the Cosmos SDK, the AppHash of a block header becomes the root. #[cfg_attr( @@ -18,7 +19,10 @@ impl ::prost::Name for MerkleRoot { const NAME: &'static str = "MerkleRoot"; const PACKAGE: &'static str = "ibc.core.commitment.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.commitment.v1.{}", Self::NAME) + "ibc.core.commitment.v1.MerkleRoot".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.commitment.v1.MerkleRoot".into() } } /// MerklePrefix is merkle path prefixed to the key. @@ -42,7 +46,10 @@ impl ::prost::Name for MerklePrefix { const NAME: &'static str = "MerklePrefix"; const PACKAGE: &'static str = "ibc.core.commitment.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.commitment.v1.{}", Self::NAME) + "ibc.core.commitment.v1.MerklePrefix".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.commitment.v1.MerklePrefix".into() } } /// MerklePath is the path used to verify commitment proofs, which can be an @@ -58,7 +65,10 @@ impl ::prost::Name for MerklePath { const NAME: &'static str = "MerklePath"; const PACKAGE: &'static str = "ibc.core.commitment.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.commitment.v1.{}", Self::NAME) + "ibc.core.commitment.v1.MerklePath".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.commitment.v1.MerklePath".into() } } /// MerkleProof is a wrapper type over a chain of CommitmentProofs. @@ -78,6 +88,9 @@ impl ::prost::Name for MerkleProof { const NAME: &'static str = "MerkleProof"; const PACKAGE: &'static str = "ibc.core.commitment.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.commitment.v1.{}", Self::NAME) + "ibc.core.commitment.v1.MerkleProof".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.commitment.v1.MerkleProof".into() } } diff --git a/src/prost/ibc.core.connection.v1.rs b/src/prost/ibc.core.connection.v1.rs index a5cb7963..d26254df 100644 --- a/src/prost/ibc.core.connection.v1.rs +++ b/src/prost/ibc.core.connection.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// ConnectionEnd defines a stateful object on a chain connected to another /// separate one. /// NOTE: there must only be 2 defined ConnectionEnds to establish @@ -32,7 +33,10 @@ impl ::prost::Name for ConnectionEnd { const NAME: &'static str = "ConnectionEnd"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.ConnectionEnd".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.ConnectionEnd".into() } } /// IdentifiedConnection defines a connection with additional connection @@ -64,7 +68,10 @@ impl ::prost::Name for IdentifiedConnection { const NAME: &'static str = "IdentifiedConnection"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.IdentifiedConnection".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.IdentifiedConnection".into() } } /// Counterparty defines the counterparty chain associated with a connection end. @@ -91,7 +98,10 @@ impl ::prost::Name for Counterparty { const NAME: &'static str = "Counterparty"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.Counterparty".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.Counterparty".into() } } /// ClientPaths define all the connection paths for a client state. @@ -106,7 +116,10 @@ impl ::prost::Name for ClientPaths { const NAME: &'static str = "ClientPaths"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.ClientPaths".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.ClientPaths".into() } } /// ConnectionPaths define all the connection paths for a given client state. @@ -124,7 +137,10 @@ impl ::prost::Name for ConnectionPaths { const NAME: &'static str = "ConnectionPaths"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.ConnectionPaths".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.ConnectionPaths".into() } } /// Version defines the versioning scheme used to negotiate the IBC verison in @@ -147,7 +163,10 @@ impl ::prost::Name for Version { const NAME: &'static str = "Version"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.Version".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.Version".into() } } /// Params defines the set of Connection parameters. @@ -164,7 +183,10 @@ impl ::prost::Name for Params { const NAME: &'static str = "Params"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.Params".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.Params".into() } } /// State defines if a connection is in one of the following states: @@ -224,7 +246,10 @@ impl ::prost::Name for GenesisState { const NAME: &'static str = "GenesisState"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.GenesisState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.GenesisState".into() } } /// MsgConnectionOpenInit defines the msg sent by an account on Chain A to @@ -247,7 +272,10 @@ impl ::prost::Name for MsgConnectionOpenInit { const NAME: &'static str = "MsgConnectionOpenInit"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.MsgConnectionOpenInit".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.MsgConnectionOpenInit".into() } } /// MsgConnectionOpenInitResponse defines the Msg/ConnectionOpenInit response @@ -259,7 +287,10 @@ impl ::prost::Name for MsgConnectionOpenInitResponse { const NAME: &'static str = "MsgConnectionOpenInitResponse"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.MsgConnectionOpenInitResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.MsgConnectionOpenInitResponse".into() } } /// MsgConnectionOpenTry defines a msg sent by a Relayer to try to open a @@ -307,7 +338,10 @@ impl ::prost::Name for MsgConnectionOpenTry { const NAME: &'static str = "MsgConnectionOpenTry"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.MsgConnectionOpenTry".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.MsgConnectionOpenTry".into() } } /// MsgConnectionOpenTryResponse defines the Msg/ConnectionOpenTry response type. @@ -318,7 +352,10 @@ impl ::prost::Name for MsgConnectionOpenTryResponse { const NAME: &'static str = "MsgConnectionOpenTryResponse"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.MsgConnectionOpenTryResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.MsgConnectionOpenTryResponse".into() } } /// MsgConnectionOpenAck defines a msg sent by a Relayer to Chain A to @@ -360,7 +397,10 @@ impl ::prost::Name for MsgConnectionOpenAck { const NAME: &'static str = "MsgConnectionOpenAck"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.MsgConnectionOpenAck".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.MsgConnectionOpenAck".into() } } /// MsgConnectionOpenAckResponse defines the Msg/ConnectionOpenAck response type. @@ -371,7 +411,10 @@ impl ::prost::Name for MsgConnectionOpenAckResponse { const NAME: &'static str = "MsgConnectionOpenAckResponse"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.MsgConnectionOpenAckResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.MsgConnectionOpenAckResponse".into() } } /// MsgConnectionOpenConfirm defines a msg sent by a Relayer to Chain B to @@ -393,7 +436,10 @@ impl ::prost::Name for MsgConnectionOpenConfirm { const NAME: &'static str = "MsgConnectionOpenConfirm"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.MsgConnectionOpenConfirm".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.MsgConnectionOpenConfirm".into() } } /// MsgConnectionOpenConfirmResponse defines the Msg/ConnectionOpenConfirm @@ -405,7 +451,10 @@ impl ::prost::Name for MsgConnectionOpenConfirmResponse { const NAME: &'static str = "MsgConnectionOpenConfirmResponse"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.MsgConnectionOpenConfirmResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.MsgConnectionOpenConfirmResponse".into() } } /// MsgUpdateParams defines the sdk.Msg type to update the connection parameters. @@ -425,7 +474,10 @@ impl ::prost::Name for MsgUpdateParams { const NAME: &'static str = "MsgUpdateParams"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.MsgUpdateParams".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.MsgUpdateParams".into() } } /// MsgUpdateParamsResponse defines the MsgUpdateParams response type. @@ -436,7 +488,10 @@ impl ::prost::Name for MsgUpdateParamsResponse { const NAME: &'static str = "MsgUpdateParamsResponse"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.MsgUpdateParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.MsgUpdateParamsResponse".into() } } /// Generated client implementations. @@ -1070,7 +1125,10 @@ impl ::prost::Name for QueryConnectionRequest { const NAME: &'static str = "QueryConnectionRequest"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.QueryConnectionRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.QueryConnectionRequest".into() } } /// QueryConnectionResponse is the response type for the Query/Connection RPC @@ -1093,7 +1151,10 @@ impl ::prost::Name for QueryConnectionResponse { const NAME: &'static str = "QueryConnectionResponse"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.QueryConnectionResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.QueryConnectionResponse".into() } } /// QueryConnectionsRequest is the request type for the Query/Connections RPC @@ -1110,7 +1171,10 @@ impl ::prost::Name for QueryConnectionsRequest { const NAME: &'static str = "QueryConnectionsRequest"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.QueryConnectionsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.QueryConnectionsRequest".into() } } /// QueryConnectionsResponse is the response type for the Query/Connections RPC @@ -1134,7 +1198,10 @@ impl ::prost::Name for QueryConnectionsResponse { const NAME: &'static str = "QueryConnectionsResponse"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.QueryConnectionsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.QueryConnectionsResponse".into() } } /// QueryClientConnectionsRequest is the request type for the @@ -1150,7 +1217,10 @@ impl ::prost::Name for QueryClientConnectionsRequest { const NAME: &'static str = "QueryClientConnectionsRequest"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.QueryClientConnectionsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.QueryClientConnectionsRequest".into() } } /// QueryClientConnectionsResponse is the response type for the @@ -1172,7 +1242,10 @@ impl ::prost::Name for QueryClientConnectionsResponse { const NAME: &'static str = "QueryClientConnectionsResponse"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.QueryClientConnectionsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.QueryClientConnectionsResponse".into() } } /// QueryConnectionClientStateRequest is the request type for the @@ -1188,7 +1261,10 @@ impl ::prost::Name for QueryConnectionClientStateRequest { const NAME: &'static str = "QueryConnectionClientStateRequest"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.QueryConnectionClientStateRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.QueryConnectionClientStateRequest".into() } } /// QueryConnectionClientStateResponse is the response type for the @@ -1212,7 +1288,10 @@ impl ::prost::Name for QueryConnectionClientStateResponse { const NAME: &'static str = "QueryConnectionClientStateResponse"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.QueryConnectionClientStateResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.QueryConnectionClientStateResponse".into() } } /// QueryConnectionConsensusStateRequest is the request type for the @@ -1232,7 +1311,10 @@ impl ::prost::Name for QueryConnectionConsensusStateRequest { const NAME: &'static str = "QueryConnectionConsensusStateRequest"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.QueryConnectionConsensusStateRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.QueryConnectionConsensusStateRequest".into() } } /// QueryConnectionConsensusStateResponse is the response type for the @@ -1259,7 +1341,10 @@ impl ::prost::Name for QueryConnectionConsensusStateResponse { const NAME: &'static str = "QueryConnectionConsensusStateResponse"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.QueryConnectionConsensusStateResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.QueryConnectionConsensusStateResponse".into() } } /// QueryConnectionParamsRequest is the request type for the Query/ConnectionParams RPC method. @@ -1270,7 +1355,10 @@ impl ::prost::Name for QueryConnectionParamsRequest { const NAME: &'static str = "QueryConnectionParamsRequest"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.QueryConnectionParamsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.QueryConnectionParamsRequest".into() } } /// QueryConnectionParamsResponse is the response type for the Query/ConnectionParams RPC method. @@ -1285,7 +1373,10 @@ impl ::prost::Name for QueryConnectionParamsResponse { const NAME: &'static str = "QueryConnectionParamsResponse"; const PACKAGE: &'static str = "ibc.core.connection.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) + "ibc.core.connection.v1.QueryConnectionParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.connection.v1.QueryConnectionParamsResponse".into() } } /// Generated client implementations. diff --git a/src/prost/ibc.core.types.v1.rs b/src/prost/ibc.core.types.v1.rs index c85e27ea..fea52458 100644 --- a/src/prost/ibc.core.types.v1.rs +++ b/src/prost/ibc.core.types.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// GenesisState defines the ibc module's genesis state. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -18,6 +19,9 @@ impl ::prost::Name for GenesisState { const NAME: &'static str = "GenesisState"; const PACKAGE: &'static str = "ibc.core.types.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.core.types.v1.{}", Self::NAME) + "ibc.core.types.v1.GenesisState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.types.v1.GenesisState".into() } } diff --git a/src/prost/ibc.lightclients.localhost.v1.rs b/src/prost/ibc.lightclients.localhost.v1.rs index 4fe8fe76..e5413e37 100644 --- a/src/prost/ibc.lightclients.localhost.v1.rs +++ b/src/prost/ibc.lightclients.localhost.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// ClientState defines a loopback (localhost) client. It requires (read-only) /// access to keys outside the client prefix. #[allow(clippy::derive_partial_eq_without_eq)] @@ -14,6 +15,9 @@ impl ::prost::Name for ClientState { const NAME: &'static str = "ClientState"; const PACKAGE: &'static str = "ibc.lightclients.localhost.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.localhost.v1.{}", Self::NAME) + "ibc.lightclients.localhost.v1.ClientState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.localhost.v1.ClientState".into() } } diff --git a/src/prost/ibc.lightclients.localhost.v2.rs b/src/prost/ibc.lightclients.localhost.v2.rs index 7032beb6..86bebfff 100644 --- a/src/prost/ibc.lightclients.localhost.v2.rs +++ b/src/prost/ibc.lightclients.localhost.v2.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// ClientState defines the 09-localhost client state #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, Copy, PartialEq, ::prost::Message)] @@ -12,6 +13,9 @@ impl ::prost::Name for ClientState { const NAME: &'static str = "ClientState"; const PACKAGE: &'static str = "ibc.lightclients.localhost.v2"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.localhost.v2.{}", Self::NAME) + "ibc.lightclients.localhost.v2.ClientState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.localhost.v2.ClientState".into() } } diff --git a/src/prost/ibc.lightclients.solomachine.v2.rs b/src/prost/ibc.lightclients.solomachine.v2.rs index d74115f8..dd87794f 100644 --- a/src/prost/ibc.lightclients.solomachine.v2.rs +++ b/src/prost/ibc.lightclients.solomachine.v2.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// ClientState defines a solo machine client that tracks the current consensus /// state and if the client is frozen. #[allow(clippy::derive_partial_eq_without_eq)] @@ -20,7 +21,10 @@ impl ::prost::Name for ClientState { const NAME: &'static str = "ClientState"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v2.{}", Self::NAME) + "ibc.lightclients.solomachine.v2.ClientState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v2.ClientState".into() } } /// ConsensusState defines a solo machine consensus state. The sequence of a @@ -46,7 +50,10 @@ impl ::prost::Name for ConsensusState { const NAME: &'static str = "ConsensusState"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v2.{}", Self::NAME) + "ibc.lightclients.solomachine.v2.ConsensusState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v2.ConsensusState".into() } } /// Header defines a solo machine consensus header @@ -71,7 +78,10 @@ impl ::prost::Name for Header { const NAME: &'static str = "Header"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v2.{}", Self::NAME) + "ibc.lightclients.solomachine.v2.Header".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v2.Header".into() } } /// Misbehaviour defines misbehaviour for a solo machine which consists @@ -92,7 +102,10 @@ impl ::prost::Name for Misbehaviour { const NAME: &'static str = "Misbehaviour"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v2.{}", Self::NAME) + "ibc.lightclients.solomachine.v2.Misbehaviour".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v2.Misbehaviour".into() } } /// SignatureAndData contains a signature and the data signed over to create that @@ -113,7 +126,10 @@ impl ::prost::Name for SignatureAndData { const NAME: &'static str = "SignatureAndData"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v2.{}", Self::NAME) + "ibc.lightclients.solomachine.v2.SignatureAndData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v2.SignatureAndData".into() } } /// TimestampedSignatureData contains the signature data and the timestamp of the @@ -130,7 +146,10 @@ impl ::prost::Name for TimestampedSignatureData { const NAME: &'static str = "TimestampedSignatureData"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v2.{}", Self::NAME) + "ibc.lightclients.solomachine.v2.TimestampedSignatureData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v2.TimestampedSignatureData".into() } } /// SignBytes defines the signed bytes used for signature verification. @@ -154,7 +173,10 @@ impl ::prost::Name for SignBytes { const NAME: &'static str = "SignBytes"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v2.{}", Self::NAME) + "ibc.lightclients.solomachine.v2.SignBytes".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v2.SignBytes".into() } } /// HeaderData returns the SignBytes data for update verification. @@ -174,7 +196,10 @@ impl ::prost::Name for HeaderData { const NAME: &'static str = "HeaderData"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v2.{}", Self::NAME) + "ibc.lightclients.solomachine.v2.HeaderData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v2.HeaderData".into() } } /// ClientStateData returns the SignBytes data for client state verification. @@ -192,7 +217,10 @@ impl ::prost::Name for ClientStateData { const NAME: &'static str = "ClientStateData"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v2.{}", Self::NAME) + "ibc.lightclients.solomachine.v2.ClientStateData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v2.ClientStateData".into() } } /// ConsensusStateData returns the SignBytes data for consensus state @@ -211,7 +239,10 @@ impl ::prost::Name for ConsensusStateData { const NAME: &'static str = "ConsensusStateData"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v2.{}", Self::NAME) + "ibc.lightclients.solomachine.v2.ConsensusStateData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v2.ConsensusStateData".into() } } /// ConnectionStateData returns the SignBytes data for connection state @@ -230,7 +261,10 @@ impl ::prost::Name for ConnectionStateData { const NAME: &'static str = "ConnectionStateData"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v2.{}", Self::NAME) + "ibc.lightclients.solomachine.v2.ConnectionStateData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v2.ConnectionStateData".into() } } /// ChannelStateData returns the SignBytes data for channel state @@ -247,7 +281,10 @@ impl ::prost::Name for ChannelStateData { const NAME: &'static str = "ChannelStateData"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v2.{}", Self::NAME) + "ibc.lightclients.solomachine.v2.ChannelStateData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v2.ChannelStateData".into() } } /// PacketCommitmentData returns the SignBytes data for packet commitment @@ -264,7 +301,10 @@ impl ::prost::Name for PacketCommitmentData { const NAME: &'static str = "PacketCommitmentData"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v2.{}", Self::NAME) + "ibc.lightclients.solomachine.v2.PacketCommitmentData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v2.PacketCommitmentData".into() } } /// PacketAcknowledgementData returns the SignBytes data for acknowledgement @@ -281,7 +321,10 @@ impl ::prost::Name for PacketAcknowledgementData { const NAME: &'static str = "PacketAcknowledgementData"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v2.{}", Self::NAME) + "ibc.lightclients.solomachine.v2.PacketAcknowledgementData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v2.PacketAcknowledgementData".into() } } /// PacketReceiptAbsenceData returns the SignBytes data for @@ -296,7 +339,10 @@ impl ::prost::Name for PacketReceiptAbsenceData { const NAME: &'static str = "PacketReceiptAbsenceData"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v2.{}", Self::NAME) + "ibc.lightclients.solomachine.v2.PacketReceiptAbsenceData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v2.PacketReceiptAbsenceData".into() } } /// NextSequenceRecvData returns the SignBytes data for verification of the next @@ -313,7 +359,10 @@ impl ::prost::Name for NextSequenceRecvData { const NAME: &'static str = "NextSequenceRecvData"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v2.{}", Self::NAME) + "ibc.lightclients.solomachine.v2.NextSequenceRecvData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v2.NextSequenceRecvData".into() } } /// DataType defines the type of solo machine proof being created. This is done diff --git a/src/prost/ibc.lightclients.solomachine.v3.rs b/src/prost/ibc.lightclients.solomachine.v3.rs index ee2d1987..d245e636 100644 --- a/src/prost/ibc.lightclients.solomachine.v3.rs +++ b/src/prost/ibc.lightclients.solomachine.v3.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// ClientState defines a solo machine client that tracks the current consensus /// state and if the client is frozen. #[allow(clippy::derive_partial_eq_without_eq)] @@ -16,7 +17,10 @@ impl ::prost::Name for ClientState { const NAME: &'static str = "ClientState"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v3"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v3.{}", Self::NAME) + "ibc.lightclients.solomachine.v3.ClientState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v3.ClientState".into() } } /// ConsensusState defines a solo machine consensus state. The sequence of a @@ -42,7 +46,10 @@ impl ::prost::Name for ConsensusState { const NAME: &'static str = "ConsensusState"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v3"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v3.{}", Self::NAME) + "ibc.lightclients.solomachine.v3.ConsensusState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v3.ConsensusState".into() } } /// Header defines a solo machine consensus header @@ -64,7 +71,10 @@ impl ::prost::Name for Header { const NAME: &'static str = "Header"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v3"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v3.{}", Self::NAME) + "ibc.lightclients.solomachine.v3.Header".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v3.Header".into() } } /// Misbehaviour defines misbehaviour for a solo machine which consists @@ -83,7 +93,10 @@ impl ::prost::Name for Misbehaviour { const NAME: &'static str = "Misbehaviour"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v3"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v3.{}", Self::NAME) + "ibc.lightclients.solomachine.v3.Misbehaviour".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v3.Misbehaviour".into() } } /// SignatureAndData contains a signature and the data signed over to create that @@ -104,7 +117,10 @@ impl ::prost::Name for SignatureAndData { const NAME: &'static str = "SignatureAndData"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v3"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v3.{}", Self::NAME) + "ibc.lightclients.solomachine.v3.SignatureAndData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v3.SignatureAndData".into() } } /// TimestampedSignatureData contains the signature data and the timestamp of the @@ -121,7 +137,10 @@ impl ::prost::Name for TimestampedSignatureData { const NAME: &'static str = "TimestampedSignatureData"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v3"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v3.{}", Self::NAME) + "ibc.lightclients.solomachine.v3.TimestampedSignatureData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v3.TimestampedSignatureData".into() } } /// SignBytes defines the signed bytes used for signature verification. @@ -148,7 +167,10 @@ impl ::prost::Name for SignBytes { const NAME: &'static str = "SignBytes"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v3"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v3.{}", Self::NAME) + "ibc.lightclients.solomachine.v3.SignBytes".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v3.SignBytes".into() } } /// HeaderData returns the SignBytes data for update verification. @@ -168,6 +190,9 @@ impl ::prost::Name for HeaderData { const NAME: &'static str = "HeaderData"; const PACKAGE: &'static str = "ibc.lightclients.solomachine.v3"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.solomachine.v3.{}", Self::NAME) + "ibc.lightclients.solomachine.v3.HeaderData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.solomachine.v3.HeaderData".into() } } diff --git a/src/prost/ibc.lightclients.tendermint.v1.rs b/src/prost/ibc.lightclients.tendermint.v1.rs index 07e71afe..a1eb7a29 100644 --- a/src/prost/ibc.lightclients.tendermint.v1.rs +++ b/src/prost/ibc.lightclients.tendermint.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// ClientState from Tendermint tracks the current validator set, latest height, /// and a possible frozen height. #[allow(clippy::derive_partial_eq_without_eq)] @@ -60,7 +61,10 @@ impl ::prost::Name for ClientState { const NAME: &'static str = "ClientState"; const PACKAGE: &'static str = "ibc.lightclients.tendermint.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.tendermint.v1.{}", Self::NAME) + "ibc.lightclients.tendermint.v1.ClientState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.tendermint.v1.ClientState".into() } } /// ConsensusState defines the consensus state from Tendermint. @@ -85,7 +89,10 @@ impl ::prost::Name for ConsensusState { const NAME: &'static str = "ConsensusState"; const PACKAGE: &'static str = "ibc.lightclients.tendermint.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.tendermint.v1.{}", Self::NAME) + "ibc.lightclients.tendermint.v1.ConsensusState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.tendermint.v1.ConsensusState".into() } } /// Misbehaviour is a wrapper over two conflicting Headers @@ -106,7 +113,10 @@ impl ::prost::Name for Misbehaviour { const NAME: &'static str = "Misbehaviour"; const PACKAGE: &'static str = "ibc.lightclients.tendermint.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.tendermint.v1.{}", Self::NAME) + "ibc.lightclients.tendermint.v1.Misbehaviour".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.tendermint.v1.Misbehaviour".into() } } /// Header defines the Tendermint client consensus Header. @@ -141,7 +151,10 @@ impl ::prost::Name for Header { const NAME: &'static str = "Header"; const PACKAGE: &'static str = "ibc.lightclients.tendermint.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.tendermint.v1.{}", Self::NAME) + "ibc.lightclients.tendermint.v1.Header".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.tendermint.v1.Header".into() } } /// Fraction defines the protobuf message type for tmmath.Fraction that only @@ -158,6 +171,9 @@ impl ::prost::Name for Fraction { const NAME: &'static str = "Fraction"; const PACKAGE: &'static str = "ibc.lightclients.tendermint.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.tendermint.v1.{}", Self::NAME) + "ibc.lightclients.tendermint.v1.Fraction".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.tendermint.v1.Fraction".into() } } diff --git a/src/prost/ibc.lightclients.wasm.v1.rs b/src/prost/ibc.lightclients.wasm.v1.rs index 4d74f303..234e7354 100644 --- a/src/prost/ibc.lightclients.wasm.v1.rs +++ b/src/prost/ibc.lightclients.wasm.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// MsgStoreCode defines the request type for the StoreCode rpc. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -13,7 +14,10 @@ impl ::prost::Name for MsgStoreCode { const NAME: &'static str = "MsgStoreCode"; const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) + "ibc.lightclients.wasm.v1.MsgStoreCode".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.wasm.v1.MsgStoreCode".into() } } /// MsgStoreCodeResponse defines the response type for the StoreCode rpc @@ -28,7 +32,10 @@ impl ::prost::Name for MsgStoreCodeResponse { const NAME: &'static str = "MsgStoreCodeResponse"; const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) + "ibc.lightclients.wasm.v1.MsgStoreCodeResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.wasm.v1.MsgStoreCodeResponse".into() } } /// MsgRemoveChecksum defines the request type for the MsgRemoveChecksum rpc. @@ -46,7 +53,10 @@ impl ::prost::Name for MsgRemoveChecksum { const NAME: &'static str = "MsgRemoveChecksum"; const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) + "ibc.lightclients.wasm.v1.MsgRemoveChecksum".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.wasm.v1.MsgRemoveChecksum".into() } } /// MsgStoreChecksumResponse defines the response type for the StoreCode rpc @@ -57,7 +67,10 @@ impl ::prost::Name for MsgRemoveChecksumResponse { const NAME: &'static str = "MsgRemoveChecksumResponse"; const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) + "ibc.lightclients.wasm.v1.MsgRemoveChecksumResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.wasm.v1.MsgRemoveChecksumResponse".into() } } /// MsgMigrateContract defines the request type for the MigrateContract rpc. @@ -81,7 +94,10 @@ impl ::prost::Name for MsgMigrateContract { const NAME: &'static str = "MsgMigrateContract"; const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) + "ibc.lightclients.wasm.v1.MsgMigrateContract".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.wasm.v1.MsgMigrateContract".into() } } /// MsgMigrateContractResponse defines the response type for the MigrateContract rpc @@ -92,7 +108,10 @@ impl ::prost::Name for MsgMigrateContractResponse { const NAME: &'static str = "MsgMigrateContractResponse"; const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) + "ibc.lightclients.wasm.v1.MsgMigrateContractResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.wasm.v1.MsgMigrateContractResponse".into() } } /// Generated client implementations. @@ -553,7 +572,10 @@ impl ::prost::Name for QueryChecksumsRequest { const NAME: &'static str = "QueryChecksumsRequest"; const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) + "ibc.lightclients.wasm.v1.QueryChecksumsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.wasm.v1.QueryChecksumsRequest".into() } } /// QueryChecksumsResponse is the response type for the Query/Checksums RPC method. @@ -573,7 +595,10 @@ impl ::prost::Name for QueryChecksumsResponse { const NAME: &'static str = "QueryChecksumsResponse"; const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) + "ibc.lightclients.wasm.v1.QueryChecksumsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.wasm.v1.QueryChecksumsResponse".into() } } /// QueryCodeRequest is the request type for the Query/Code RPC method. @@ -588,7 +613,10 @@ impl ::prost::Name for QueryCodeRequest { const NAME: &'static str = "QueryCodeRequest"; const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) + "ibc.lightclients.wasm.v1.QueryCodeRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.wasm.v1.QueryCodeRequest".into() } } /// QueryCodeResponse is the response type for the Query/Code RPC method. @@ -602,7 +630,10 @@ impl ::prost::Name for QueryCodeResponse { const NAME: &'static str = "QueryCodeResponse"; const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) + "ibc.lightclients.wasm.v1.QueryCodeResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.wasm.v1.QueryCodeResponse".into() } } /// Generated client implementations. @@ -982,7 +1013,10 @@ impl ::prost::Name for GenesisState { const NAME: &'static str = "GenesisState"; const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) + "ibc.lightclients.wasm.v1.GenesisState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.wasm.v1.GenesisState".into() } } /// Contract stores contract code @@ -997,7 +1031,10 @@ impl ::prost::Name for Contract { const NAME: &'static str = "Contract"; const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) + "ibc.lightclients.wasm.v1.Contract".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.wasm.v1.Contract".into() } } /// Wasm light client's Client state @@ -1019,7 +1056,10 @@ impl ::prost::Name for ClientState { const NAME: &'static str = "ClientState"; const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) + "ibc.lightclients.wasm.v1.ClientState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.wasm.v1.ClientState".into() } } /// Wasm light client's ConsensusState @@ -1035,7 +1075,10 @@ impl ::prost::Name for ConsensusState { const NAME: &'static str = "ConsensusState"; const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) + "ibc.lightclients.wasm.v1.ConsensusState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.wasm.v1.ConsensusState".into() } } /// Wasm light client message (either header(s) or misbehaviour) @@ -1053,7 +1096,10 @@ impl ::prost::Name for ClientMessage { const NAME: &'static str = "ClientMessage"; const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) + "ibc.lightclients.wasm.v1.ClientMessage".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.wasm.v1.ClientMessage".into() } } /// Checksums defines a list of all checksums that are stored @@ -1070,6 +1116,9 @@ impl ::prost::Name for Checksums { const NAME: &'static str = "Checksums"; const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) + "ibc.lightclients.wasm.v1.Checksums".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.lightclients.wasm.v1.Checksums".into() } } diff --git a/src/prost/ibc.mock.rs b/src/prost/ibc.mock.rs index b43adfa9..51f0287a 100644 --- a/src/prost/ibc.mock.rs +++ b/src/prost/ibc.mock.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, Copy, PartialEq, ::prost::Message)] pub struct Header { @@ -10,7 +11,10 @@ impl ::prost::Name for Header { const NAME: &'static str = "Header"; const PACKAGE: &'static str = "ibc.mock"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.mock.{}", Self::NAME) + "ibc.mock.Header".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.mock.Header".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -27,7 +31,10 @@ impl ::prost::Name for ClientState { const NAME: &'static str = "ClientState"; const PACKAGE: &'static str = "ibc.mock"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.mock.{}", Self::NAME) + "ibc.mock.ClientState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.mock.ClientState".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -40,7 +47,10 @@ impl ::prost::Name for ConsensusState { const NAME: &'static str = "ConsensusState"; const PACKAGE: &'static str = "ibc.mock"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.mock.{}", Self::NAME) + "ibc.mock.ConsensusState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.mock.ConsensusState".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -57,6 +67,9 @@ impl ::prost::Name for Misbehaviour { const NAME: &'static str = "Misbehaviour"; const PACKAGE: &'static str = "ibc.mock"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.mock.{}", Self::NAME) + "ibc.mock.Misbehaviour".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.mock.Misbehaviour".into() } } diff --git a/src/prost/interchain_security.ccv.consumer.v1.rs b/src/prost/interchain_security.ccv.consumer.v1.rs index f1bc2acd..418b0e43 100644 --- a/src/prost/interchain_security.ccv.consumer.v1.rs +++ b/src/prost/interchain_security.ccv.consumer.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// CrossChainValidator defines the type used to store validator information internal /// to the consumer CCV module. Note one cross chain validator entry is persisted for /// each consumer validator, where incoming VSC packets update this data, which is eventually @@ -21,7 +22,10 @@ impl ::prost::Name for CrossChainValidator { const NAME: &'static str = "CrossChainValidator"; const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.consumer.v1.{}", Self::NAME) + "interchain_security.ccv.consumer.v1.CrossChainValidator".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.consumer.v1.CrossChainValidator".into() } } /// A record storing the state of a slash packet sent to the provider chain @@ -42,7 +46,10 @@ impl ::prost::Name for SlashRecord { const NAME: &'static str = "SlashRecord"; const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.consumer.v1.{}", Self::NAME) + "interchain_security.ccv.consumer.v1.SlashRecord".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.consumer.v1.SlashRecord".into() } } /// NextFeeDistributionEstimate holds information about next fee distribution @@ -75,7 +82,10 @@ impl ::prost::Name for NextFeeDistributionEstimate { const NAME: &'static str = "NextFeeDistributionEstimate"; const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.consumer.v1.{}", Self::NAME) + "interchain_security.ccv.consumer.v1.NextFeeDistributionEstimate".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.consumer.v1.NextFeeDistributionEstimate".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -85,7 +95,12 @@ impl ::prost::Name for QueryNextFeeDistributionEstimateRequest { const NAME: &'static str = "QueryNextFeeDistributionEstimateRequest"; const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.consumer.v1.{}", Self::NAME) + "interchain_security.ccv.consumer.v1.QueryNextFeeDistributionEstimateRequest" + .into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.consumer.v1.QueryNextFeeDistributionEstimateRequest" + .into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -98,7 +113,12 @@ impl ::prost::Name for QueryNextFeeDistributionEstimateResponse { const NAME: &'static str = "QueryNextFeeDistributionEstimateResponse"; const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.consumer.v1.{}", Self::NAME) + "interchain_security.ccv.consumer.v1.QueryNextFeeDistributionEstimateResponse" + .into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.consumer.v1.QueryNextFeeDistributionEstimateResponse" + .into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -108,7 +128,10 @@ impl ::prost::Name for QueryParamsRequest { const NAME: &'static str = "QueryParamsRequest"; const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.consumer.v1.{}", Self::NAME) + "interchain_security.ccv.consumer.v1.QueryParamsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.consumer.v1.QueryParamsRequest".into() } } /// QueryParamsResponse is response type for the Query/Params RPC method. @@ -123,7 +146,10 @@ impl ::prost::Name for QueryParamsResponse { const NAME: &'static str = "QueryParamsResponse"; const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.consumer.v1.{}", Self::NAME) + "interchain_security.ccv.consumer.v1.QueryParamsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.consumer.v1.QueryParamsResponse".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -133,7 +159,10 @@ impl ::prost::Name for QueryProviderInfoRequest { const NAME: &'static str = "QueryProviderInfoRequest"; const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.consumer.v1.{}", Self::NAME) + "interchain_security.ccv.consumer.v1.QueryProviderInfoRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.consumer.v1.QueryProviderInfoRequest".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -148,7 +177,10 @@ impl ::prost::Name for QueryProviderInfoResponse { const NAME: &'static str = "QueryProviderInfoResponse"; const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.consumer.v1.{}", Self::NAME) + "interchain_security.ccv.consumer.v1.QueryProviderInfoResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.consumer.v1.QueryProviderInfoResponse".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -167,7 +199,10 @@ impl ::prost::Name for ChainInfo { const NAME: &'static str = "ChainInfo"; const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.consumer.v1.{}", Self::NAME) + "interchain_security.ccv.consumer.v1.ChainInfo".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.consumer.v1.ChainInfo".into() } } /// Generated client implementations. diff --git a/src/prost/interchain_security.ccv.provider.v1.rs b/src/prost/interchain_security.ccv.provider.v1.rs index 9e0de3d5..5c2a3e14 100644 --- a/src/prost/interchain_security.ccv.provider.v1.rs +++ b/src/prost/interchain_security.ccv.provider.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgAssignConsumerKey { @@ -17,7 +18,10 @@ impl ::prost::Name for MsgAssignConsumerKey { const NAME: &'static str = "MsgAssignConsumerKey"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.MsgAssignConsumerKey".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.MsgAssignConsumerKey".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -27,7 +31,10 @@ impl ::prost::Name for MsgAssignConsumerKeyResponse { const NAME: &'static str = "MsgAssignConsumerKeyResponse"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.MsgAssignConsumerKeyResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.MsgAssignConsumerKeyResponse".into() } } /// MsgSubmitConsumerMisbehaviour defines a message that reports a light client attack, @@ -48,7 +55,10 @@ impl ::prost::Name for MsgSubmitConsumerMisbehaviour { const NAME: &'static str = "MsgSubmitConsumerMisbehaviour"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.MsgSubmitConsumerMisbehaviour".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.MsgSubmitConsumerMisbehaviour".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -58,7 +68,12 @@ impl ::prost::Name for MsgSubmitConsumerMisbehaviourResponse { const NAME: &'static str = "MsgSubmitConsumerMisbehaviourResponse"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.MsgSubmitConsumerMisbehaviourResponse" + .into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.MsgSubmitConsumerMisbehaviourResponse" + .into() } } /// MsgSubmitConsumerDoubleVoting defines a message that reports @@ -84,7 +99,10 @@ impl ::prost::Name for MsgSubmitConsumerDoubleVoting { const NAME: &'static str = "MsgSubmitConsumerDoubleVoting"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.MsgSubmitConsumerDoubleVoting".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.MsgSubmitConsumerDoubleVoting".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -94,7 +112,12 @@ impl ::prost::Name for MsgSubmitConsumerDoubleVotingResponse { const NAME: &'static str = "MsgSubmitConsumerDoubleVotingResponse"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.MsgSubmitConsumerDoubleVotingResponse" + .into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.MsgSubmitConsumerDoubleVotingResponse" + .into() } } /// Generated client implementations. @@ -639,7 +662,10 @@ impl ::prost::Name for ConsumerAdditionProposal { const NAME: &'static str = "ConsumerAdditionProposal"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.ConsumerAdditionProposal".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.ConsumerAdditionProposal".into() } } /// ConsumerRemovalProposal is a governance proposal on the provider chain to @@ -669,7 +695,10 @@ impl ::prost::Name for ConsumerRemovalProposal { const NAME: &'static str = "ConsumerRemovalProposal"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.ConsumerRemovalProposal".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.ConsumerRemovalProposal".into() } } /// ChangeRewardDenomsProposal is a governance proposal on the provider chain to @@ -694,7 +723,10 @@ impl ::prost::Name for ChangeRewardDenomsProposal { const NAME: &'static str = "ChangeRewardDenomsProposal"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.ChangeRewardDenomsProposal".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.ChangeRewardDenomsProposal".into() } } /// A persisted queue entry indicating that a slash packet data instance needs to @@ -728,7 +760,10 @@ impl ::prost::Name for GlobalSlashEntry { const NAME: &'static str = "GlobalSlashEntry"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.GlobalSlashEntry".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.GlobalSlashEntry".into() } } /// Params defines the parameters for CCV Provider module @@ -786,7 +821,10 @@ impl ::prost::Name for Params { const NAME: &'static str = "Params"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.Params".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.Params".into() } } /// SlashAcks contains cons addresses of consumer chain validators @@ -801,7 +839,10 @@ impl ::prost::Name for SlashAcks { const NAME: &'static str = "SlashAcks"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.SlashAcks".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.SlashAcks".into() } } /// ConsumerAdditionProposals holds pending governance proposals on the provider @@ -817,7 +858,10 @@ impl ::prost::Name for ConsumerAdditionProposals { const NAME: &'static str = "ConsumerAdditionProposals"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.ConsumerAdditionProposals".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.ConsumerAdditionProposals".into() } } /// ConsumerRemovalProposals holds pending governance proposals on the provider @@ -833,7 +877,10 @@ impl ::prost::Name for ConsumerRemovalProposals { const NAME: &'static str = "ConsumerRemovalProposals"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.ConsumerRemovalProposals".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.ConsumerRemovalProposals".into() } } /// AddressList contains a list of consensus addresses @@ -847,7 +894,10 @@ impl ::prost::Name for AddressList { const NAME: &'static str = "AddressList"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.AddressList".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.AddressList".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -862,7 +912,10 @@ impl ::prost::Name for ChannelToChain { const NAME: &'static str = "ChannelToChain"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.ChannelToChain".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.ChannelToChain".into() } } /// VscUnbondingOps contains the IDs of unbonding operations that are waiting for @@ -879,7 +932,10 @@ impl ::prost::Name for VscUnbondingOps { const NAME: &'static str = "VscUnbondingOps"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.VscUnbondingOps".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.VscUnbondingOps".into() } } /// UnbondingOp contains the ids of consumer chains that need to unbond before @@ -899,7 +955,10 @@ impl ::prost::Name for UnbondingOp { const NAME: &'static str = "UnbondingOp"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.UnbondingOp".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.UnbondingOp".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -914,7 +973,10 @@ impl ::prost::Name for InitTimeoutTimestamp { const NAME: &'static str = "InitTimeoutTimestamp"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.InitTimeoutTimestamp".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.InitTimeoutTimestamp".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -931,7 +993,10 @@ impl ::prost::Name for VscSendTimestamp { const NAME: &'static str = "VscSendTimestamp"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.VscSendTimestamp".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.VscSendTimestamp".into() } } /// ValidatorSetChangePackets is a pb list of ccv.ValidatorSetChangePacketData. @@ -945,7 +1010,10 @@ impl ::prost::Name for ValidatorSetChangePackets { const NAME: &'static str = "ValidatorSetChangePackets"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.ValidatorSetChangePackets".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.ValidatorSetChangePackets".into() } } /// MaturedUnbondingOps defines a list of ids corresponding to ids of matured @@ -960,7 +1028,10 @@ impl ::prost::Name for MaturedUnbondingOps { const NAME: &'static str = "MaturedUnbondingOps"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.MaturedUnbondingOps".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.MaturedUnbondingOps".into() } } /// ExportedVscSendTimestamps is VscSendTimestamp with chainID info for exporting to genesis @@ -976,7 +1047,10 @@ impl ::prost::Name for ExportedVscSendTimestamp { const NAME: &'static str = "ExportedVscSendTimestamp"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.ExportedVscSendTimestamp".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.ExportedVscSendTimestamp".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -993,7 +1067,10 @@ impl ::prost::Name for KeyAssignmentReplacement { const NAME: &'static str = "KeyAssignmentReplacement"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.KeyAssignmentReplacement".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.KeyAssignmentReplacement".into() } } /// Used to serialize the ValidatorConsumerPubKey index from key assignment @@ -1013,7 +1090,10 @@ impl ::prost::Name for ValidatorConsumerPubKey { const NAME: &'static str = "ValidatorConsumerPubKey"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.ValidatorConsumerPubKey".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.ValidatorConsumerPubKey".into() } } /// Used to serialize the ValidatorConsumerAddr index from key assignment @@ -1033,7 +1113,10 @@ impl ::prost::Name for ValidatorByConsumerAddr { const NAME: &'static str = "ValidatorByConsumerAddr"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.ValidatorByConsumerAddr".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.ValidatorByConsumerAddr".into() } } /// Used to serialize the ConsumerAddrsToPrune index from key assignment @@ -1052,7 +1135,10 @@ impl ::prost::Name for ConsumerAddrsToPrune { const NAME: &'static str = "ConsumerAddrsToPrune"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.ConsumerAddrsToPrune".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.ConsumerAddrsToPrune".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1065,7 +1151,10 @@ impl ::prost::Name for QueryConsumerGenesisRequest { const NAME: &'static str = "QueryConsumerGenesisRequest"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.QueryConsumerGenesisRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.QueryConsumerGenesisRequest".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1078,7 +1167,10 @@ impl ::prost::Name for QueryConsumerGenesisResponse { const NAME: &'static str = "QueryConsumerGenesisResponse"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.QueryConsumerGenesisResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.QueryConsumerGenesisResponse".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1088,7 +1180,10 @@ impl ::prost::Name for QueryConsumerChainsRequest { const NAME: &'static str = "QueryConsumerChainsRequest"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.QueryConsumerChainsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.QueryConsumerChainsRequest".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1101,7 +1196,10 @@ impl ::prost::Name for QueryConsumerChainsResponse { const NAME: &'static str = "QueryConsumerChainsResponse"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.QueryConsumerChainsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.QueryConsumerChainsResponse".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1111,7 +1209,12 @@ impl ::prost::Name for QueryConsumerChainStartProposalsRequest { const NAME: &'static str = "QueryConsumerChainStartProposalsRequest"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.QueryConsumerChainStartProposalsRequest" + .into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.QueryConsumerChainStartProposalsRequest" + .into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1124,7 +1227,12 @@ impl ::prost::Name for QueryConsumerChainStartProposalsResponse { const NAME: &'static str = "QueryConsumerChainStartProposalsResponse"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.QueryConsumerChainStartProposalsResponse" + .into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.QueryConsumerChainStartProposalsResponse" + .into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1134,7 +1242,12 @@ impl ::prost::Name for QueryConsumerChainStopProposalsRequest { const NAME: &'static str = "QueryConsumerChainStopProposalsRequest"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.QueryConsumerChainStopProposalsRequest" + .into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.QueryConsumerChainStopProposalsRequest" + .into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1147,7 +1260,12 @@ impl ::prost::Name for QueryConsumerChainStopProposalsResponse { const NAME: &'static str = "QueryConsumerChainStopProposalsResponse"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.QueryConsumerChainStopProposalsResponse" + .into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.QueryConsumerChainStopProposalsResponse" + .into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1162,7 +1280,10 @@ impl ::prost::Name for Chain { const NAME: &'static str = "Chain"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.Chain".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.Chain".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1179,7 +1300,10 @@ impl ::prost::Name for QueryValidatorConsumerAddrRequest { const NAME: &'static str = "QueryValidatorConsumerAddrRequest"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.QueryValidatorConsumerAddrRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.QueryValidatorConsumerAddrRequest".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1193,7 +1317,10 @@ impl ::prost::Name for QueryValidatorConsumerAddrResponse { const NAME: &'static str = "QueryValidatorConsumerAddrResponse"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.QueryValidatorConsumerAddrResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.QueryValidatorConsumerAddrResponse".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1210,7 +1337,10 @@ impl ::prost::Name for QueryValidatorProviderAddrRequest { const NAME: &'static str = "QueryValidatorProviderAddrRequest"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.QueryValidatorProviderAddrRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.QueryValidatorProviderAddrRequest".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1224,7 +1354,10 @@ impl ::prost::Name for QueryValidatorProviderAddrResponse { const NAME: &'static str = "QueryValidatorProviderAddrResponse"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.QueryValidatorProviderAddrResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.QueryValidatorProviderAddrResponse".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1234,7 +1367,10 @@ impl ::prost::Name for QueryThrottleStateRequest { const NAME: &'static str = "QueryThrottleStateRequest"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.QueryThrottleStateRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.QueryThrottleStateRequest".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1261,7 +1397,10 @@ impl ::prost::Name for QueryThrottleStateResponse { const NAME: &'static str = "QueryThrottleStateResponse"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.QueryThrottleStateResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.QueryThrottleStateResponse".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1274,7 +1413,12 @@ impl ::prost::Name for QueryThrottledConsumerPacketDataRequest { const NAME: &'static str = "QueryThrottledConsumerPacketDataRequest"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.QueryThrottledConsumerPacketDataRequest" + .into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.QueryThrottledConsumerPacketDataRequest" + .into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1291,7 +1435,12 @@ impl ::prost::Name for QueryThrottledConsumerPacketDataResponse { const NAME: &'static str = "QueryThrottledConsumerPacketDataResponse"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.QueryThrottledConsumerPacketDataResponse" + .into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.QueryThrottledConsumerPacketDataResponse" + .into() } } /// A query wrapper type for the global entry and data relevant to a throttled @@ -1308,7 +1457,10 @@ impl ::prost::Name for ThrottledSlashPacket { const NAME: &'static str = "ThrottledSlashPacket"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.ThrottledSlashPacket".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.ThrottledSlashPacket".into() } } /// ThrottledPacketDataWrapper contains either SlashPacketData or @@ -1334,7 +1486,10 @@ impl ::prost::Name for ThrottledPacketDataWrapper { const NAME: &'static str = "ThrottledPacketDataWrapper"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.ThrottledPacketDataWrapper".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.ThrottledPacketDataWrapper".into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1344,7 +1499,12 @@ impl ::prost::Name for QueryRegisteredConsumerRewardDenomsRequest { const NAME: &'static str = "QueryRegisteredConsumerRewardDenomsRequest"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.QueryRegisteredConsumerRewardDenomsRequest" + .into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.QueryRegisteredConsumerRewardDenomsRequest" + .into() } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -1357,7 +1517,12 @@ impl ::prost::Name for QueryRegisteredConsumerRewardDenomsResponse { const NAME: &'static str = "QueryRegisteredConsumerRewardDenomsResponse"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.QueryRegisteredConsumerRewardDenomsResponse" + .into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.QueryRegisteredConsumerRewardDenomsResponse" + .into() } } /// Generated client implementations. @@ -2420,7 +2585,10 @@ impl ::prost::Name for GenesisState { const NAME: &'static str = "GenesisState"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.GenesisState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.GenesisState".into() } } /// The provider CCV module's knowledge of consumer state. @@ -2461,7 +2629,10 @@ impl ::prost::Name for ConsumerState { const NAME: &'static str = "ConsumerState"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.ConsumerState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.ConsumerState".into() } } /// ValsetUpdateIdToHeight defines the genesis information for the mapping @@ -2478,6 +2649,9 @@ impl ::prost::Name for ValsetUpdateIdToHeight { const NAME: &'static str = "ValsetUpdateIdToHeight"; const PACKAGE: &'static str = "interchain_security.ccv.provider.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.provider.v1.{}", Self::NAME) + "interchain_security.ccv.provider.v1.ValsetUpdateIdToHeight".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.provider.v1.ValsetUpdateIdToHeight".into() } } diff --git a/src/prost/interchain_security.ccv.v1.rs b/src/prost/interchain_security.ccv.v1.rs index 636fa08d..f9cca6c6 100644 --- a/src/prost/interchain_security.ccv.v1.rs +++ b/src/prost/interchain_security.ccv.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// This packet is sent from provider chain to consumer chain if the validator /// set for consumer chain changes (due to new bonding/unbonding messages or /// slashing events) A VSCMatured packet from consumer chain will be sent @@ -21,7 +22,10 @@ impl ::prost::Name for ValidatorSetChangePacketData { const NAME: &'static str = "ValidatorSetChangePacketData"; const PACKAGE: &'static str = "interchain_security.ccv.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.v1.{}", Self::NAME) + "interchain_security.ccv.v1.ValidatorSetChangePacketData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.v1.ValidatorSetChangePacketData".into() } } /// This packet is sent from the consumer chain to the provider chain @@ -37,7 +41,10 @@ impl ::prost::Name for VscMaturedPacketData { const NAME: &'static str = "VSCMaturedPacketData"; const PACKAGE: &'static str = "interchain_security.ccv.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.v1.{}", Self::NAME) + "interchain_security.ccv.v1.VSCMaturedPacketData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.v1.VSCMaturedPacketData".into() } } /// This packet is sent from the consumer chain to the provider chain @@ -62,7 +69,10 @@ impl ::prost::Name for SlashPacketData { const NAME: &'static str = "SlashPacketData"; const PACKAGE: &'static str = "interchain_security.ccv.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.v1.{}", Self::NAME) + "interchain_security.ccv.v1.SlashPacketData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.v1.SlashPacketData".into() } } /// ConsumerPacketData contains a consumer packet data and a type tag @@ -89,7 +99,10 @@ impl ::prost::Name for ConsumerPacketData { const NAME: &'static str = "ConsumerPacketData"; const PACKAGE: &'static str = "interchain_security.ccv.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.v1.{}", Self::NAME) + "interchain_security.ccv.v1.ConsumerPacketData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.v1.ConsumerPacketData".into() } } /// Note this type is used during IBC handshake methods for both the consumer and provider @@ -105,7 +118,10 @@ impl ::prost::Name for HandshakeMetadata { const NAME: &'static str = "HandshakeMetadata"; const PACKAGE: &'static str = "interchain_security.ccv.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.v1.{}", Self::NAME) + "interchain_security.ccv.v1.HandshakeMetadata".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.v1.HandshakeMetadata".into() } } /// ConsumerPacketData contains a consumer packet data and a type tag @@ -133,7 +149,10 @@ impl ::prost::Name for ConsumerPacketDataV1 { const NAME: &'static str = "ConsumerPacketDataV1"; const PACKAGE: &'static str = "interchain_security.ccv.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.v1.{}", Self::NAME) + "interchain_security.ccv.v1.ConsumerPacketDataV1".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.v1.ConsumerPacketDataV1".into() } } /// This packet is sent from the consumer chain to the provider chain @@ -154,7 +173,10 @@ impl ::prost::Name for SlashPacketDataV1 { const NAME: &'static str = "SlashPacketDataV1"; const PACKAGE: &'static str = "interchain_security.ccv.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.v1.{}", Self::NAME) + "interchain_security.ccv.v1.SlashPacketDataV1".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.v1.SlashPacketDataV1".into() } } /// ConsumerPacketType indicates interchain security specific packet types. @@ -303,7 +325,10 @@ impl ::prost::Name for ConsumerParams { const NAME: &'static str = "ConsumerParams"; const PACKAGE: &'static str = "interchain_security.ccv.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.v1.{}", Self::NAME) + "interchain_security.ccv.v1.ConsumerParams".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.v1.ConsumerParams".into() } } /// ConsumerGenesisState defines the CCV consumer chain genesis state. @@ -364,7 +389,10 @@ impl ::prost::Name for ConsumerGenesisState { const NAME: &'static str = "ConsumerGenesisState"; const PACKAGE: &'static str = "interchain_security.ccv.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.v1.{}", Self::NAME) + "interchain_security.ccv.v1.ConsumerGenesisState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.v1.ConsumerGenesisState".into() } } /// HeightValsetUpdateID represents a mapping internal to the consumer CCV module @@ -381,7 +409,10 @@ impl ::prost::Name for HeightToValsetUpdateId { const NAME: &'static str = "HeightToValsetUpdateID"; const PACKAGE: &'static str = "interchain_security.ccv.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.v1.{}", Self::NAME) + "interchain_security.ccv.v1.HeightToValsetUpdateID".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.v1.HeightToValsetUpdateID".into() } } /// OutstandingDowntime defines the type used internally to the consumer CCV module, @@ -397,7 +428,10 @@ impl ::prost::Name for OutstandingDowntime { const NAME: &'static str = "OutstandingDowntime"; const PACKAGE: &'static str = "interchain_security.ccv.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.v1.{}", Self::NAME) + "interchain_security.ccv.v1.OutstandingDowntime".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.v1.OutstandingDowntime".into() } } /// LastTransmissionBlockHeight is the last time validator holding @@ -413,7 +447,10 @@ impl ::prost::Name for LastTransmissionBlockHeight { const NAME: &'static str = "LastTransmissionBlockHeight"; const PACKAGE: &'static str = "interchain_security.ccv.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.v1.{}", Self::NAME) + "interchain_security.ccv.v1.LastTransmissionBlockHeight".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.v1.LastTransmissionBlockHeight".into() } } /// MaturingVSCPacket represents a vsc packet that is maturing internal to the @@ -434,7 +471,10 @@ impl ::prost::Name for MaturingVscPacket { const NAME: &'static str = "MaturingVSCPacket"; const PACKAGE: &'static str = "interchain_security.ccv.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.v1.{}", Self::NAME) + "interchain_security.ccv.v1.MaturingVSCPacket".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.v1.MaturingVSCPacket".into() } } /// ConsumerPacketDataList is a list of consumer packet data packets. @@ -453,6 +493,9 @@ impl ::prost::Name for ConsumerPacketDataList { const NAME: &'static str = "ConsumerPacketDataList"; const PACKAGE: &'static str = "interchain_security.ccv.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("interchain_security.ccv.v1.{}", Self::NAME) + "interchain_security.ccv.v1.ConsumerPacketDataList".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/interchain_security.ccv.v1.ConsumerPacketDataList".into() } } diff --git a/src/prost/proto_descriptor.bin b/src/prost/proto_descriptor.bin index 39bcf87fb82f3f7573523203ba1f62af20391c0f..6bf1c56a64307c34676631e1536b830ee6d61a41 100644 GIT binary patch delta 1118 zcmaLWO-NKx6ae5kXYPCR-W~jV{)9i_%j}nCKvN@Esby{iQ-g>ImByc%R2-$GO{-iK zM5|lv+5{49GJ29I%7`Edgr}%(c5s&_#XDAv^f4Hfl6q=5GSK8cbbLd|SgSUc-oQQC<tf|E0lX?&l7X8iAp*Pr0oKh1YOK?X@>_a7y-v`bZphIK* zqVESh$m>T`cpR6^L7-7olVYjUOjA<%JIg2zO&&y?5?w#xZNeZb3H*{(i`1~FS%u4< zVPrgt!5l?*d@Q9}!bw0X{TpF7-Hh)1mcxUY! za1okCH7<%=gk~`@i9gy#ipIi5#|C7AH*6z?P#D#;C{hT8F+GzHY+tpiv4|M>1A}D| z#Mt$ywCM=ClcPqZ5)n)}6icZ@1dkr$XX#%=O`b=`3jK>G^%60>4q4*kCgdi}qms_^ z=?kFwnid4#f&$M%Y+E!)H5X!Mp_FPam}e=p2u&`FYg=$4d)X%Dqgl2I5LxaS*#Zir Wa8fV|i9)7uQ79CuF|x(WhyDVnR0Ku< delta 1142 zcma*mPe>F|7y$77zIi)4`xaey`~$0kqf38`c0toMf+DrdOCahYq9Ucu3?*Y%@UT#J zF)E2puWlWpgLNsQIY=R>B`sK*df4!=NKhELfvv8Y_RYA<+@yhTnD5Q|ee*uvo6mm& zLz{t{ub_Jz68hC~c#6)KVeU}vxwZ}6`wk}T`J-(d8L09o+I}GvKX21~`p+2LlfBLD z?JZhV>uPOjnFU$eW#Wr@2ufO%i{w017in$%ou@e0oO_e7Rzli!2d~{Eu;^ybfTBN2#*&1B%Pa)$O z48|zBaZ%GI~q+=+0IJ+D79DrNqJ()c8}` zwa_3HN@W|MlnSMc25L=0FVmuK8|uo^7BNmr+9E(CJv6)x6i6XaFbX?`OyQtVD4hE6 IHg9_S53~UN@Bjb+ diff --git a/src/prost/stride.interchainquery.v1.rs b/src/prost/stride.interchainquery.v1.rs index 4ae30691..26702ff5 100644 --- a/src/prost/stride.interchainquery.v1.rs +++ b/src/prost/stride.interchainquery.v1.rs @@ -1,3 +1,4 @@ +// This file is @generated by prost-build. /// MsgSubmitQueryResponse represents a message type to fulfil a query request. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -19,7 +20,10 @@ impl ::prost::Name for MsgSubmitQueryResponse { const NAME: &'static str = "MsgSubmitQueryResponse"; const PACKAGE: &'static str = "stride.interchainquery.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("stride.interchainquery.v1.{}", Self::NAME) + "stride.interchainquery.v1.MsgSubmitQueryResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/stride.interchainquery.v1.MsgSubmitQueryResponse".into() } } /// MsgSubmitQueryResponseResponse defines the MsgSubmitQueryResponse response @@ -31,7 +35,10 @@ impl ::prost::Name for MsgSubmitQueryResponseResponse { const NAME: &'static str = "MsgSubmitQueryResponseResponse"; const PACKAGE: &'static str = "stride.interchainquery.v1"; fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("stride.interchainquery.v1.{}", Self::NAME) + "stride.interchainquery.v1.MsgSubmitQueryResponseResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/stride.interchainquery.v1.MsgSubmitQueryResponseResponse".into() } } /// Generated client implementations.