From 364e997d48b99ce27b177fea30c0734545e17703 Mon Sep 17 00:00:00 2001 From: Carlos Rodriguez Date: Tue, 9 Jan 2024 09:21:31 +0100 Subject: [PATCH] sync ibc-go with tag `04-channel-upgrades-rc.0` (#179) --- src/IBC_GO_COMMIT | 2 +- src/lib.rs | 6 +- src/prost/google.protobuf.rs | 640 +++++++++++++++++++++++++++++-- src/prost/ibc.core.channel.v1.rs | 236 +++++++++++- src/prost/proto_descriptor.bin | Bin 702918 -> 737265 bytes 5 files changed, 842 insertions(+), 42 deletions(-) diff --git a/src/IBC_GO_COMMIT b/src/IBC_GO_COMMIT index 47f08cce..8c33106a 100644 --- a/src/IBC_GO_COMMIT +++ b/src/IBC_GO_COMMIT @@ -1 +1 @@ -2551dea41cd3c512845007ca895c8402afa9b79f +7a89e5d5b5ebb7643ce3992c34008c35373ecf34 diff --git a/src/lib.rs b/src/lib.rs index 4287448b..5abf7bf4 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -5,7 +5,11 @@ #![cfg_attr(not(feature = "std"), no_std)] #![deny(warnings, trivial_casts, trivial_numeric_casts, unused_import_braces)] -#![allow(clippy::large_enum_variant, clippy::derive_partial_eq_without_eq)] +#![allow( + clippy::large_enum_variant, + clippy::derive_partial_eq_without_eq, + clippy::needless_borrows_for_generic_args +)] #![allow(rustdoc::bare_urls)] #![forbid(unsafe_code)] diff --git a/src/prost/google.protobuf.rs b/src/prost/google.protobuf.rs index 3878889e..33731f49 100644 --- a/src/prost/google.protobuf.rs +++ b/src/prost/google.protobuf.rs @@ -22,8 +22,12 @@ /// if (any.is(Foo.class)) { /// foo = any.unpack(Foo.class); /// } +/// // or ... +/// if (any.isSameTypeAs(Foo.getDefaultInstance())) { +/// foo = any.unpack(Foo.getDefaultInstance()); +/// } /// -/// Example 3: Pack and unpack a message in Python. +/// Example 3: Pack and unpack a message in Python. /// /// foo = Foo(...) /// any = Any() @@ -33,7 +37,7 @@ /// any.Unpack(foo) /// ... /// -/// Example 4: Pack and unpack a message in Go +/// Example 4: Pack and unpack a message in Go /// /// foo := &pb.Foo{...} /// any, err := anypb.New(foo) @@ -52,9 +56,8 @@ /// in the type URL, for example "foo.bar.com/x/y.z" will yield type /// name "y.z". /// -/// /// JSON -/// +/// ==== /// The JSON representation of an `Any` value uses the regular /// representation of the deserialized, embedded message, with an /// additional field `@type` which contains the type URL. Example: @@ -113,7 +116,8 @@ pub struct Any { /// /// Note: this functionality is not currently available in the official /// protobuf release, and it is not used for type URLs beginning with - /// type.googleapis.com. + /// type.googleapis.com. As of May 2023, there are no widely used type server + /// implementations and no plans to implement one. /// /// Schemes other than `http`, `https` (or the empty scheme) might be /// used with implementation specific semantics. @@ -170,9 +174,14 @@ pub struct FileDescriptorProto { #[prost(message, optional, tag = "9")] pub source_code_info: ::core::option::Option, /// The syntax of the proto file. - /// The supported values are "proto2" and "proto3". + /// The supported values are "proto2", "proto3", and "editions". + /// + /// 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>, } /// Describes a message type. #[allow(clippy::derive_partial_eq_without_eq)] @@ -235,6 +244,90 @@ pub struct ExtensionRangeOptions { /// The parser stores options it doesn't recognize here. See above. #[prost(message, repeated, tag = "999")] pub uninterpreted_option: ::prost::alloc::vec::Vec, + /// For external users: DO NOT USE. We are in the process of open sourcing + /// extension declaration and executing internal cleanups before it can be + /// used externally. + #[prost(message, repeated, tag = "2")] + pub declaration: ::prost::alloc::vec::Vec, + /// Any features defined in the specific edition. + #[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 + /// are marked as UNVERIFIED. + #[prost( + enumeration = "extension_range_options::VerificationState", + optional, + tag = "3", + default = "Unverified" + )] + pub verification: ::core::option::Option, +} +/// Nested message and enum types in `ExtensionRangeOptions`. +pub mod extension_range_options { + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct Declaration { + /// The extension number declared within the extension range. + #[prost(int32, optional, tag = "1")] + pub number: ::core::option::Option, + /// The fully-qualified name of the extension field. There must be a leading + /// dot in front of the full name. + #[prost(string, optional, tag = "2")] + pub full_name: ::core::option::Option<::prost::alloc::string::String>, + /// The fully-qualified type name of the extension field. Unlike + /// Metadata.type, Declaration.type must have a leading dot for messages + /// and enums. + #[prost(string, optional, tag = "3")] + pub r#type: ::core::option::Option<::prost::alloc::string::String>, + /// If true, indicates that the number is reserved in the extension range, + /// and any extension field with the number will fail to compile. Set this + /// when a declared extension field is deleted. + #[prost(bool, optional, tag = "5")] + pub reserved: ::core::option::Option, + /// If true, indicates that the extension must be defined as repeated. + /// Otherwise the extension must be defined as optional. + #[prost(bool, optional, tag = "6")] + pub repeated: ::core::option::Option, + } + /// The verification state of the extension range. + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum VerificationState { + /// All the extensions of the range must be declared. + Declaration = 0, + Unverified = 1, + } + impl VerificationState { + /// 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 { + VerificationState::Declaration => "DECLARATION", + VerificationState::Unverified => "UNVERIFIED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "DECLARATION" => Some(Self::Declaration), + "UNVERIFIED" => Some(Self::Unverified), + _ => None, + } + } + } } /// Describes a field within a message. #[allow(clippy::derive_partial_eq_without_eq)] @@ -647,6 +740,9 @@ pub struct FileOptions { /// determining the ruby package. #[prost(string, optional, tag = "45")] pub ruby_package: ::core::option::Option<::prost::alloc::string::String>, + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "50")] + pub features: ::core::option::Option, /// The parser stores options it doesn't recognize here. /// See the documentation for the "Options" section above. #[prost(message, repeated, tag = "999")] @@ -734,6 +830,10 @@ 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. /// @@ -751,12 +851,24 @@ 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 + /// 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. + /// + /// 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 + /// teams have had time to migrate. + #[deprecated] + #[prost(bool, optional, tag = "11")] + pub deprecated_legacy_json_field_conflicts: ::core::option::Option, + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "12")] + pub features: ::core::option::Option, /// The parser stores options it doesn't recognize here. See above. #[prost(message, repeated, tag = "999")] pub uninterpreted_option: ::prost::alloc::vec::Vec, @@ -766,8 +878,10 @@ pub struct MessageOptions { pub struct FieldOptions { /// The ctype option instructs the C++ code generator to use a different /// representation of the field than it normally would. See the specific - /// options below. This option is not yet implemented in the open source - /// release -- sorry, we'll try to include it in a future version! + /// options below. This option is only implemented to support use of + /// \[ctype=CORD\] and \[ctype=STRING\] (the default) on non-repeated fields of + /// type "bytes" in the open source release -- sorry, we'll try to include + /// other types in a future version! #[prost( enumeration = "field_options::CType", optional, @@ -817,7 +931,6 @@ 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. @@ -829,11 +942,8 @@ pub struct FieldOptions { /// check its required fields, regardless of whether or not the message has /// been parsed. /// - /// As of 2021, lazy does no correctness checks on the byte stream during - /// parsing. This may lead to crashes if and when an invalid byte stream is - /// finally parsed upon access. - /// - /// TODO(b/211906113): Enable validation on lazy fields. + /// 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. #[prost(bool, optional, tag = "5", default = "false")] pub lazy: ::core::option::Option, /// unverified_lazy does no correctness checks on the byte stream. This should @@ -850,12 +960,39 @@ pub struct FieldOptions { /// For Google-internal migration only. Do not use. #[prost(bool, optional, tag = "10", default = "false")] pub weak: ::core::option::Option, + /// Indicate that the field value should not be printed out when using debug + /// formats, e.g. when the field contains sensitive credentials. + #[prost(bool, optional, tag = "16", default = "false")] + pub debug_redact: ::core::option::Option, + #[prost(enumeration = "field_options::OptionRetention", optional, tag = "17")] + pub retention: ::core::option::Option, + #[prost( + enumeration = "field_options::OptionTargetType", + repeated, + packed = "false", + tag = "19" + )] + pub targets: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag = "20")] + pub edition_defaults: ::prost::alloc::vec::Vec, + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "21")] + pub features: ::core::option::Option, /// The parser stores options it doesn't recognize here. See above. #[prost(message, repeated, tag = "999")] pub uninterpreted_option: ::prost::alloc::vec::Vec, } /// Nested message and enum types in `FieldOptions`. 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>, + /// Textproto value. + #[prost(string, optional, tag = "2")] + pub value: ::core::option::Option<::prost::alloc::string::String>, + } #[derive( Clone, Copy, @@ -871,6 +1008,12 @@ pub mod field_options { pub enum CType { /// Default mode. String = 0, + /// The option \[ctype=CORD\] may be applied to a non-repeated field of type + /// "bytes". It indicates that in C++, the data should be stored in a Cord + /// instead of a string. For very large strings, this may reduce memory + /// fragmentation. It may also allow better performance when parsing from a + /// Cord, or when parsing with aliasing enabled, as the parsed Cord may then + /// alias the original buffer. Cord = 1, StringPiece = 2, } @@ -938,10 +1081,121 @@ pub mod field_options { } } } + /// If set to RETENTION_SOURCE, the option will be omitted from the binary. + /// Note: as of January 2023, support for this is in progress and does not yet + /// have an effect (b/264593489). + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum OptionRetention { + RetentionUnknown = 0, + RetentionRuntime = 1, + RetentionSource = 2, + } + impl OptionRetention { + /// 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 { + OptionRetention::RetentionUnknown => "RETENTION_UNKNOWN", + OptionRetention::RetentionRuntime => "RETENTION_RUNTIME", + OptionRetention::RetentionSource => "RETENTION_SOURCE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "RETENTION_UNKNOWN" => Some(Self::RetentionUnknown), + "RETENTION_RUNTIME" => Some(Self::RetentionRuntime), + "RETENTION_SOURCE" => Some(Self::RetentionSource), + _ => None, + } + } + } + /// This indicates the types of entities that the field may apply to when used + /// as an option. If it is unset, then the field may be freely used as an + /// option on any kind of entity. Note: as of January 2023, support for this is + /// in progress and does not yet have an effect (b/264593489). + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum OptionTargetType { + TargetTypeUnknown = 0, + TargetTypeFile = 1, + TargetTypeExtensionRange = 2, + TargetTypeMessage = 3, + TargetTypeField = 4, + TargetTypeOneof = 5, + TargetTypeEnum = 6, + TargetTypeEnumEntry = 7, + TargetTypeService = 8, + TargetTypeMethod = 9, + } + impl OptionTargetType { + /// 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 { + OptionTargetType::TargetTypeUnknown => "TARGET_TYPE_UNKNOWN", + OptionTargetType::TargetTypeFile => "TARGET_TYPE_FILE", + OptionTargetType::TargetTypeExtensionRange => { + "TARGET_TYPE_EXTENSION_RANGE" + } + OptionTargetType::TargetTypeMessage => "TARGET_TYPE_MESSAGE", + OptionTargetType::TargetTypeField => "TARGET_TYPE_FIELD", + OptionTargetType::TargetTypeOneof => "TARGET_TYPE_ONEOF", + OptionTargetType::TargetTypeEnum => "TARGET_TYPE_ENUM", + OptionTargetType::TargetTypeEnumEntry => "TARGET_TYPE_ENUM_ENTRY", + OptionTargetType::TargetTypeService => "TARGET_TYPE_SERVICE", + OptionTargetType::TargetTypeMethod => "TARGET_TYPE_METHOD", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "TARGET_TYPE_UNKNOWN" => Some(Self::TargetTypeUnknown), + "TARGET_TYPE_FILE" => Some(Self::TargetTypeFile), + "TARGET_TYPE_EXTENSION_RANGE" => Some(Self::TargetTypeExtensionRange), + "TARGET_TYPE_MESSAGE" => Some(Self::TargetTypeMessage), + "TARGET_TYPE_FIELD" => Some(Self::TargetTypeField), + "TARGET_TYPE_ONEOF" => Some(Self::TargetTypeOneof), + "TARGET_TYPE_ENUM" => Some(Self::TargetTypeEnum), + "TARGET_TYPE_ENUM_ENTRY" => Some(Self::TargetTypeEnumEntry), + "TARGET_TYPE_SERVICE" => Some(Self::TargetTypeService), + "TARGET_TYPE_METHOD" => Some(Self::TargetTypeMethod), + _ => None, + } + } + } } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct OneofOptions { + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "1")] + pub features: ::core::option::Option, /// The parser stores options it doesn't recognize here. See above. #[prost(message, repeated, tag = "999")] pub uninterpreted_option: ::prost::alloc::vec::Vec, @@ -959,6 +1213,18 @@ pub struct EnumOptions { /// is a formalization for deprecating enums. #[prost(bool, optional, tag = "3", default = "false")] pub deprecated: ::core::option::Option, + /// Enable the legacy handling of JSON field name conflicts. This lowercases + /// 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 + /// had time to migrate. + #[deprecated] + #[prost(bool, optional, tag = "6")] + pub deprecated_legacy_json_field_conflicts: ::core::option::Option, + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "7")] + pub features: ::core::option::Option, /// The parser stores options it doesn't recognize here. See above. #[prost(message, repeated, tag = "999")] pub uninterpreted_option: ::prost::alloc::vec::Vec, @@ -972,6 +1238,14 @@ pub struct EnumValueOptions { /// this is a formalization for deprecating enum values. #[prost(bool, optional, tag = "1", default = "false")] pub deprecated: ::core::option::Option, + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "2")] + pub features: ::core::option::Option, + /// Indicate that fields annotated with this enum value should not be printed + /// out when using debug formats, e.g. when the field contains sensitive + /// credentials. + #[prost(bool, optional, tag = "3", default = "false")] + pub debug_redact: ::core::option::Option, /// The parser stores options it doesn't recognize here. See above. #[prost(message, repeated, tag = "999")] pub uninterpreted_option: ::prost::alloc::vec::Vec, @@ -979,6 +1253,9 @@ pub struct EnumValueOptions { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ServiceOptions { + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "34")] + pub features: ::core::option::Option, /// Is this service deprecated? /// Depending on the target platform, this can emit Deprecated annotations /// for the service, or it will be completely ignored; in the very least, @@ -1005,6 +1282,9 @@ pub struct MethodOptions { default = "IdempotencyUnknown" )] pub idempotency_level: ::core::option::Option, + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "35")] + pub features: ::core::option::Option, /// The parser stores options it doesn't recognize here. See above. #[prost(message, repeated, tag = "999")] pub uninterpreted_option: ::prost::alloc::vec::Vec, @@ -1098,6 +1378,273 @@ pub mod uninterpreted_option { pub is_extension: bool, } } +/// TODO(b/274655146) 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 +/// be designed and implemented to handle this, hopefully before we ever hit a +/// conflict here. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FeatureSet { + #[prost(enumeration = "feature_set::FieldPresence", optional, tag = "1")] + pub field_presence: ::core::option::Option, + #[prost(enumeration = "feature_set::EnumType", optional, tag = "2")] + 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::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 { + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum FieldPresence { + Unknown = 0, + Explicit = 1, + Implicit = 2, + LegacyRequired = 3, + } + impl FieldPresence { + /// 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 { + FieldPresence::Unknown => "FIELD_PRESENCE_UNKNOWN", + FieldPresence::Explicit => "EXPLICIT", + FieldPresence::Implicit => "IMPLICIT", + FieldPresence::LegacyRequired => "LEGACY_REQUIRED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "FIELD_PRESENCE_UNKNOWN" => Some(Self::Unknown), + "EXPLICIT" => Some(Self::Explicit), + "IMPLICIT" => Some(Self::Implicit), + "LEGACY_REQUIRED" => Some(Self::LegacyRequired), + _ => None, + } + } + } + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum EnumType { + Unknown = 0, + Open = 1, + Closed = 2, + } + impl EnumType { + /// 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 { + EnumType::Unknown => "ENUM_TYPE_UNKNOWN", + EnumType::Open => "OPEN", + EnumType::Closed => "CLOSED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ENUM_TYPE_UNKNOWN" => Some(Self::Unknown), + "OPEN" => Some(Self::Open), + "CLOSED" => Some(Self::Closed), + _ => None, + } + } + } + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum RepeatedFieldEncoding { + Unknown = 0, + Packed = 1, + Expanded = 2, + } + impl RepeatedFieldEncoding { + /// 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 { + RepeatedFieldEncoding::Unknown => "REPEATED_FIELD_ENCODING_UNKNOWN", + RepeatedFieldEncoding::Packed => "PACKED", + RepeatedFieldEncoding::Expanded => "EXPANDED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "REPEATED_FIELD_ENCODING_UNKNOWN" => Some(Self::Unknown), + "PACKED" => Some(Self::Packed), + "EXPANDED" => Some(Self::Expanded), + _ => None, + } + } + } + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum StringFieldValidation { + Unknown = 0, + Mandatory = 1, + Hint = 2, + None = 3, + } + impl StringFieldValidation { + /// 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", + } + } + /// 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), + "NONE" => Some(Self::None), + _ => None, + } + } + } + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum MessageEncoding { + Unknown = 0, + LengthPrefixed = 1, + Delimited = 2, + } + impl MessageEncoding { + /// 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 { + MessageEncoding::Unknown => "MESSAGE_ENCODING_UNKNOWN", + MessageEncoding::LengthPrefixed => "LENGTH_PREFIXED", + MessageEncoding::Delimited => "DELIMITED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "MESSAGE_ENCODING_UNKNOWN" => Some(Self::Unknown), + "LENGTH_PREFIXED" => Some(Self::LengthPrefixed), + "DELIMITED" => Some(Self::Delimited), + _ => None, + } + } + } + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum JsonFormat { + Unknown = 0, + Allow = 1, + LegacyBestEffort = 2, + } + impl JsonFormat { + /// 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 { + JsonFormat::Unknown => "JSON_FORMAT_UNKNOWN", + JsonFormat::Allow => "ALLOW", + JsonFormat::LegacyBestEffort => "LEGACY_BEST_EFFORT", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "JSON_FORMAT_UNKNOWN" => Some(Self::Unknown), + "ALLOW" => Some(Self::Allow), + "LEGACY_BEST_EFFORT" => Some(Self::LegacyBestEffort), + _ => None, + } + } + } +} /// Encapsulates information about the original source file from which a /// FileDescriptorProto was generated. #[allow(clippy::derive_partial_eq_without_eq)] @@ -1271,10 +1818,59 @@ pub mod generated_code_info { #[prost(int32, optional, tag = "3")] pub begin: ::core::option::Option, /// Identifies the ending offset in bytes in the generated code that - /// relates to the identified offset. The end offset should be one past + /// relates to the identified object. The end offset should be one past /// the last relevant byte (so the length of the text = end - begin). #[prost(int32, optional, tag = "4")] pub end: ::core::option::Option, + #[prost(enumeration = "annotation::Semantic", optional, tag = "5")] + pub semantic: ::core::option::Option, + } + /// Nested message and enum types in `Annotation`. + pub mod annotation { + /// Represents the identified object's effect on the element in the original + /// .proto file. + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum Semantic { + /// There is no effect or the effect is indescribable. + None = 0, + /// The element is set or otherwise mutated. + Set = 1, + /// An alias to the element is returned. + Alias = 2, + } + impl Semantic { + /// 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 { + Semantic::None => "NONE", + Semantic::Set => "SET", + Semantic::Alias => "ALIAS", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "NONE" => Some(Self::None), + "SET" => Some(Self::Set), + "ALIAS" => Some(Self::Alias), + _ => None, + } + } + } } } /// A Timestamp represents a point in time independent of any time zone or local @@ -1327,7 +1923,6 @@ pub mod generated_code_info { /// Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) /// .setNanos((int) ((millis % 1000) * 1000000)).build(); /// -/// /// Example 5: Compute Timestamp from Java `Instant.now()`. /// /// Instant now = Instant.now(); @@ -1336,7 +1931,6 @@ pub mod generated_code_info { /// Timestamp.newBuilder().setSeconds(now.getEpochSecond()) /// .setNanos(now.getNano()).build(); /// -/// /// Example 6: Compute Timestamp from current time in Python. /// /// timestamp = Timestamp() @@ -1366,10 +1960,9 @@ pub mod generated_code_info { /// [`strftime`]() with /// the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use /// the Joda Time's [`ISODateTimeFormat.dateTime()`]( -/// +/// ) /// ) to obtain a formatter capable of generating timestamps in this format. /// -/// #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -1445,7 +2038,6 @@ pub struct Timestamp { /// be expressed in JSON format as "3.000000001s", and 3 seconds and 1 /// microsecond should be expressed in JSON format as "3.000001s". /// -/// #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[derive(Eq)] #[allow(clippy::derive_partial_eq_without_eq)] diff --git a/src/prost/ibc.core.channel.v1.rs b/src/prost/ibc.core.channel.v1.rs index 9e13647a..b6053be0 100644 --- a/src/prost/ibc.core.channel.v1.rs +++ b/src/prost/ibc.core.channel.v1.rs @@ -58,6 +58,10 @@ pub struct IdentifiedChannel { /// channel identifier #[prost(string, tag = "7")] pub channel_id: ::prost::alloc::string::String, + /// upgrade sequence indicates the latest upgrade attempt performed by this channel + /// the value of 0 indicates the channel has never been upgraded + #[prost(uint64, tag = "8")] + pub upgrade_sequence: u64, } /// Counterparty defines a channel end counterparty #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] @@ -324,8 +328,9 @@ pub struct PacketSequence { } /// Upgrade is a verifiable type which contains the relevant information /// for an attempted upgrade. It provides the proposed changes to the channel -/// end, the timeout for this upgrade attempt and the latest packet sequence sent -/// to allow the counterparty to block sends after the upgrade has started. +/// end, the timeout for this upgrade attempt and the next packet sequence +/// which allows the counterparty to efficiently know the highest sequence it has received. +/// The next sequence send is used for pruning and upgrading from unordered to ordered channels. #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -335,7 +340,7 @@ pub struct Upgrade { #[prost(message, optional, tag = "2")] pub timeout: ::core::option::Option, #[prost(uint64, tag = "3")] - pub latest_sequence_send: u64, + pub next_sequence_send: u64, } /// UpgradeFields are the fields in a channel end which may be changed /// during a channel upgrade. @@ -505,6 +510,8 @@ pub struct MsgChannelCloseConfirm { pub proof_height: ::core::option::Option, #[prost(string, tag = "5")] pub signer: ::prost::alloc::string::String, + #[prost(uint64, tag = "6")] + pub counterparty_upgrade_sequence: u64, } /// MsgChannelCloseConfirmResponse defines the Msg/ChannelCloseConfirm response /// type. @@ -575,6 +582,8 @@ pub struct MsgTimeoutOnClose { pub next_sequence_recv: u64, #[prost(string, tag = "6")] pub signer: ::prost::alloc::string::String, + #[prost(uint64, tag = "7")] + pub counterparty_upgrade_sequence: u64, } /// MsgTimeoutOnCloseResponse defines the Msg/TimeoutOnClose response type. #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] @@ -627,11 +636,9 @@ pub struct MsgChannelUpgradeInit { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeInitResponse { - #[prost(string, tag = "1")] - pub channel_id: ::prost::alloc::string::String, - #[prost(message, optional, tag = "2")] + #[prost(message, optional, tag = "1")] pub upgrade: ::core::option::Option, - #[prost(uint64, tag = "3")] + #[prost(uint64, tag = "2")] pub upgrade_sequence: u64, } /// MsgChannelUpgradeTry defines the request type for the ChannelUpgradeTry rpc @@ -665,13 +672,11 @@ pub struct MsgChannelUpgradeTry { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeTryResponse { - #[prost(string, tag = "1")] - pub channel_id: ::prost::alloc::string::String, - #[prost(message, optional, tag = "2")] + #[prost(message, optional, tag = "1")] pub upgrade: ::core::option::Option, - #[prost(uint64, tag = "3")] + #[prost(uint64, tag = "2")] pub upgrade_sequence: u64, - #[prost(enumeration = "ResponseResultType", tag = "4")] + #[prost(enumeration = "ResponseResultType", tag = "3")] pub result: i32, } /// MsgChannelUpgradeAck defines the request type for the ChannelUpgradeAck rpc @@ -777,10 +782,7 @@ pub struct MsgChannelUpgradeTimeout { #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgChannelUpgradeTimeoutResponse { - #[prost(enumeration = "ResponseResultType", tag = "1")] - pub result: i32, -} +pub struct MsgChannelUpgradeTimeoutResponse {} /// MsgChannelUpgradeCancel defines the request type for the ChannelUpgradeCancel rpc #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] @@ -823,6 +825,32 @@ pub struct MsgUpdateParams { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgUpdateParamsResponse {} +/// MsgPruneAcknowledgements defines the request type for the PruneAcknowledgements rpc. +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgPruneAcknowledgements { + #[prost(string, tag = "1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(uint64, tag = "3")] + pub limit: u64, + #[prost(string, tag = "4")] + pub signer: ::prost::alloc::string::String, +} +/// MsgPruneAcknowledgementsResponse defines the response type for the PruneAcknowledgements rpc. +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgPruneAcknowledgementsResponse { + /// Number of sequences pruned (includes both packet acknowledgements and packet receipts where appropriate). + #[prost(uint64, tag = "1")] + pub total_pruned_sequences: u64, + /// Number of sequences left after pruning. + #[prost(uint64, tag = "2")] + pub total_remaining_sequences: u64, +} /// ResponseResultType defines the possible outcomes of the execution of a message #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] @@ -1433,6 +1461,34 @@ pub mod msg_client { ); self.inner.unary(req, path, codec).await } + /// PruneAcknowledgements defines a rpc handler method for MsgPruneAcknowledgements. + pub async fn prune_acknowledgements( + &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/PruneAcknowledgements", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("ibc.core.channel.v1.Msg", "PruneAcknowledgements"), + ); + self.inner.unary(req, path, codec).await + } } } /// Generated server implementations. @@ -1588,6 +1644,14 @@ pub mod msg_server { tonic::Response, tonic::Status, >; + /// PruneAcknowledgements defines a rpc handler method for MsgPruneAcknowledgements. + async fn prune_acknowledgements( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; } /// Msg defines the ibc/channel Msg service. #[derive(Debug)] @@ -2475,6 +2539,52 @@ pub mod msg_server { }; Box::pin(fut) } + "/ibc.core.channel.v1.Msg/PruneAcknowledgements" => { + #[allow(non_camel_case_types)] + struct PruneAcknowledgementsSvc(pub Arc); + impl< + T: Msg, + > tonic::server::UnaryService + for PruneAcknowledgementsSvc { + type Response = super::MsgPruneAcknowledgementsResponse; + 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 { + ::prune_acknowledgements(&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 = PruneAcknowledgementsSvc(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) + } _ => { Box::pin(async move { Ok( @@ -3013,6 +3123,20 @@ pub struct QueryUpgradeResponse { #[prost(message, optional, tag = "3")] pub proof_height: ::core::option::Option, } +/// QueryChannelParamsRequest is the request type for the Query/ChannelParams RPC method. +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryChannelParamsRequest {} +/// QueryChannelParamsResponse is the response type for the Query/ChannelParams RPC method. +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryChannelParamsResponse { + /// params defines the parameters of the module. + #[prost(message, optional, tag = "1")] + pub params: ::core::option::Option, +} /// Generated client implementations. #[cfg(feature = "client")] pub mod query_client { @@ -3547,6 +3671,32 @@ pub mod query_client { .insert(GrpcMethod::new("ibc.core.channel.v1.Query", "Upgrade")); self.inner.unary(req, path, codec).await } + /// ChannelParams queries all parameters of the ibc channel submodule. + pub async fn channel_params( + &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.Query/ChannelParams", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("ibc.core.channel.v1.Query", "ChannelParams")); + self.inner.unary(req, path, codec).await + } } } /// Generated server implementations. @@ -3693,6 +3843,14 @@ pub mod query_server { tonic::Response, tonic::Status, >; + /// ChannelParams queries all parameters of the ibc channel submodule. + async fn channel_params( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; } /// Query provides defines the gRPC querier service #[derive(Debug)] @@ -4525,6 +4683,52 @@ pub mod query_server { }; Box::pin(fut) } + "/ibc.core.channel.v1.Query/ChannelParams" => { + #[allow(non_camel_case_types)] + struct ChannelParamsSvc(pub Arc); + impl< + T: Query, + > tonic::server::UnaryService + for ChannelParamsSvc { + type Response = super::QueryChannelParamsResponse; + 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_params(&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 = ChannelParamsSvc(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) + } _ => { Box::pin(async move { Ok( diff --git a/src/prost/proto_descriptor.bin b/src/prost/proto_descriptor.bin index bb1bdf04b84fa0804aba2499b430697819814b7f..67a1abe35e79458536cd8533e680298e87afd0ed 100644 GIT binary patch delta 64508 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