diff --git a/src/IBC_GO_COMMIT b/src/IBC_GO_COMMIT index 8a6720b..5fbbaa6 100644 --- a/src/IBC_GO_COMMIT +++ b/src/IBC_GO_COMMIT @@ -1 +1 @@ -a4ef5360b49ad2118e1d68f25f13935162660e0b \ No newline at end of file +66ebf864d7bfe2193a96c972a9e74196b2ddf104 \ No newline at end of file diff --git a/src/lib.rs b/src/lib.rs index 5f2843a..296a28d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -332,6 +332,11 @@ pub mod ibc { #[cfg(feature = "serde")] include_proto!("ibc.core.commitment.v1.serde.rs"); } + pub mod v2 { + include_proto!("ibc.core.commitment.v2.rs"); + #[cfg(feature = "serde")] + include_proto!("ibc.core.commitment.v2.serde.rs"); + } } pub mod connection { pub mod v1 { diff --git a/src/prost/google.protobuf.rs b/src/prost/google.protobuf.rs index 4822b53..0dd604d 100644 --- a/src/prost/google.protobuf.rs +++ b/src/prost/google.protobuf.rs @@ -455,12 +455,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 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 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. /// /// For message fields, proto3_optional doesn't create any semantic change, /// since non-repeated message fields always track presence. However it still @@ -854,6 +854,8 @@ 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 @@ -996,6 +998,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. /// @@ -1013,10 +1019,6 @@ 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 @@ -1109,11 +1111,19 @@ pub struct FieldOptions { /// call from multiple threads concurrently, while non-const methods continue /// to require exclusive access. /// - /// 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). + /// 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. #[prost(bool, optional, tag = "5", default = "false")] pub lazy: ::core::option::Option, /// unverified_lazy does no correctness checks on the byte stream. This should @@ -1834,8 +1844,8 @@ pub mod feature_set { #[repr(i32)] pub enum Utf8Validation { Unknown = 0, + None = 1, Verify = 2, - None = 3, } impl Utf8Validation { /// String value of the enum field names used in the ProtoBuf definition. @@ -1845,16 +1855,16 @@ pub mod feature_set { pub fn as_str_name(&self) -> &'static str { match self { Utf8Validation::Unknown => "UTF8_VALIDATION_UNKNOWN", - Utf8Validation::Verify => "VERIFY", Utf8Validation::None => "NONE", + Utf8Validation::Verify => "VERIFY", } } /// Creates an enum from field names used in the ProtoBuf definition. pub fn from_str_name(value: &str) -> ::core::option::Option { match value { "UTF8_VALIDATION_UNKNOWN" => Some(Self::Unknown), - "VERIFY" => Some(Self::Verify), "NONE" => Some(Self::None), + "VERIFY" => Some(Self::Verify), _ => None, } } @@ -2067,7 +2077,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 appears. + /// the root FileDescriptorProto to the place where the definition occurs. /// For example, this path: /// \[ 4, 3, 2, 7, 1 \] /// refers to: @@ -2294,7 +2304,6 @@ pub enum Edition { /// 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, @@ -2302,10 +2311,6 @@ pub enum Edition { 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. @@ -2319,13 +2324,11 @@ impl Edition { 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. @@ -2336,13 +2339,11 @@ impl Edition { "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, } } diff --git a/src/prost/google.protobuf.serde.rs b/src/prost/google.protobuf.serde.rs index b47f4a5..4e644c1 100644 --- a/src/prost/google.protobuf.serde.rs +++ b/src/prost/google.protobuf.serde.rs @@ -726,13 +726,11 @@ impl serde::Serialize for Edition { 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) } @@ -749,13 +747,11 @@ impl<'de> serde::Deserialize<'de> for Edition { "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; @@ -801,13 +797,11 @@ impl<'de> serde::Deserialize<'de> for Edition { "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)), } } @@ -2492,8 +2486,8 @@ impl serde::Serialize for feature_set::Utf8Validation { { let variant = match self { Self::Unknown => "UTF8_VALIDATION_UNKNOWN", - Self::Verify => "VERIFY", Self::None => "NONE", + Self::Verify => "VERIFY", }; serializer.serialize_str(variant) } @@ -2506,8 +2500,8 @@ impl<'de> serde::Deserialize<'de> for feature_set::Utf8Validation { { const FIELDS: &[&str] = &[ "UTF8_VALIDATION_UNKNOWN", - "VERIFY", "NONE", + "VERIFY", ]; struct GeneratedVisitor; @@ -2549,8 +2543,8 @@ impl<'de> serde::Deserialize<'de> for feature_set::Utf8Validation { { match value { "UTF8_VALIDATION_UNKNOWN" => Ok(feature_set::Utf8Validation::Unknown), - "VERIFY" => Ok(feature_set::Utf8Validation::Verify), "NONE" => Ok(feature_set::Utf8Validation::None), + "VERIFY" => Ok(feature_set::Utf8Validation::Verify), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -4661,6 +4655,9 @@ 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)?; @@ -4694,6 +4691,9 @@ 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)?; } @@ -4757,6 +4757,8 @@ impl<'de> serde::Deserialize<'de> for FileOptions { "javaGenericServices", "py_generic_services", "pyGenericServices", + "php_generic_services", + "phpGenericServices", "deprecated", "cc_enable_arenas", "ccEnableArenas", @@ -4791,6 +4793,7 @@ impl<'de> serde::Deserialize<'de> for FileOptions { CcGenericServices, JavaGenericServices, PyGenericServices, + PhpGenericServices, Deprecated, CcEnableArenas, ObjcClassPrefix, @@ -4833,6 +4836,7 @@ 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), @@ -4873,6 +4877,7 @@ 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; @@ -4946,6 +4951,12 @@ 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")); @@ -5025,6 +5036,7 @@ 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/ibc.applications.fee.v1.rs b/src/prost/ibc.applications.fee.v1.rs index 6a199df..5cdaf9c 100644 --- a/src/prost/ibc.applications.fee.v1.rs +++ b/src/prost/ibc.applications.fee.v1.rs @@ -188,7 +188,7 @@ pub struct MsgPayPacketFee { /// the source port unique identifier #[prost(string, tag = "2")] pub source_port_id: ::prost::alloc::string::String, - /// the source channel unique identifer + /// the source channel unique identifier #[prost(string, tag = "3")] pub source_channel_id: ::prost::alloc::string::String, /// account address to refund fee if necessary @@ -948,7 +948,7 @@ pub struct ForwardRelayerAddress { /// the forward relayer address #[prost(string, tag = "1")] pub address: ::prost::alloc::string::String, - /// unique packet identifer comprised of the channel ID, port ID and sequence + /// unique packet identifier comprised of the channel ID, port ID and sequence #[prost(message, optional, tag = "2")] pub packet_id: ::core::option::Option< super::super::super::core::channel::v1::PacketId, @@ -1033,7 +1033,7 @@ impl ::prost::Name for QueryIncentivizedPacketRequest { "/ibc.applications.fee.v1.QueryIncentivizedPacketRequest".into() } } -/// QueryIncentivizedPacketsResponse defines the response type for the IncentivizedPacket rpc +/// QueryIncentivizedPacketResponse defines the response type for the IncentivizedPacket rpc #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryIncentivizedPacketResponse { @@ -1079,7 +1079,8 @@ impl ::prost::Name for QueryIncentivizedPacketsForChannelRequest { "/ibc.applications.fee.v1.QueryIncentivizedPacketsForChannelRequest".into() } } -/// QueryIncentivizedPacketsResponse defines the response type for the incentivized packets RPC +/// QueryIncentivizedPacketsForChannelResponse defines the response type for querying for all incentivized packets +/// for a specific channel #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryIncentivizedPacketsForChannelResponse { diff --git a/src/prost/ibc.applications.interchain_accounts.host.v1.rs b/src/prost/ibc.applications.interchain_accounts.host.v1.rs index b5b61d4..e5065d7 100644 --- a/src/prost/ibc.applications.interchain_accounts.host.v1.rs +++ b/src/prost/ibc.applications.interchain_accounts.host.v1.rs @@ -21,6 +21,30 @@ impl ::prost::Name for Params { "/ibc.applications.interchain_accounts.host.v1.Params".into() } } +/// QueryRequest defines the parameters for a particular query request +/// by an interchain account. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryRequest { + /// path defines the path of the query request as defined by ADR-021. + /// + #[prost(string, tag = "1")] + pub path: ::prost::alloc::string::String, + /// data defines the payload of the query request as defined by ADR-021. + /// + #[prost(bytes = "vec", tag = "2")] + pub data: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for QueryRequest { + const NAME: &'static str = "QueryRequest"; + const PACKAGE: &'static str = "ibc.applications.interchain_accounts.host.v1"; + fn full_name() -> ::prost::alloc::string::String { + "ibc.applications.interchain_accounts.host.v1.QueryRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.host.v1.QueryRequest".into() + } +} /// MsgUpdateParams defines the payload for Msg/UpdateParams #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -58,6 +82,48 @@ impl ::prost::Name for MsgUpdateParamsResponse { "/ibc.applications.interchain_accounts.host.v1.MsgUpdateParamsResponse".into() } } +/// MsgModuleQuerySafe defines the payload for Msg/ModuleQuerySafe +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgModuleQuerySafe { + /// signer address + #[prost(string, tag = "1")] + pub signer: ::prost::alloc::string::String, + /// requests defines the module safe queries to execute. + #[prost(message, repeated, tag = "2")] + pub requests: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for MsgModuleQuerySafe { + const NAME: &'static str = "MsgModuleQuerySafe"; + const PACKAGE: &'static str = "ibc.applications.interchain_accounts.host.v1"; + fn full_name() -> ::prost::alloc::string::String { + "ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafe".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafe".into() + } +} +/// MsgModuleQuerySafeResponse defines the response for Msg/ModuleQuerySafe +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgModuleQuerySafeResponse { + /// height at which the responses were queried + #[prost(uint64, tag = "1")] + pub height: u64, + /// protobuf encoded responses for each query + #[prost(bytes = "vec", repeated, tag = "2")] + pub responses: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, +} +impl ::prost::Name for MsgModuleQuerySafeResponse { + const NAME: &'static str = "MsgModuleQuerySafeResponse"; + const PACKAGE: &'static str = "ibc.applications.interchain_accounts.host.v1"; + fn full_name() -> ::prost::alloc::string::String { + "ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafeResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafeResponse".into() + } +} /// Generated client implementations. #[cfg(feature = "client")] pub mod msg_client { @@ -176,6 +242,37 @@ pub mod msg_client { ); self.inner.unary(req, path, codec).await } + /// ModuleQuerySafe defines a rpc handler for MsgModuleQuerySafe. + pub async fn module_query_safe( + &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.applications.interchain_accounts.host.v1.Msg/ModuleQuerySafe", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "ibc.applications.interchain_accounts.host.v1.Msg", + "ModuleQuerySafe", + ), + ); + self.inner.unary(req, path, codec).await + } } } /// Generated server implementations. @@ -194,6 +291,14 @@ pub mod msg_server { tonic::Response, tonic::Status, >; + /// ModuleQuerySafe defines a rpc handler for MsgModuleQuerySafe. + async fn module_query_safe( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; } /// Msg defines the 27-interchain-accounts/host Msg service. #[derive(Debug)] @@ -315,6 +420,49 @@ pub mod msg_server { }; Box::pin(fut) } + "/ibc.applications.interchain_accounts.host.v1.Msg/ModuleQuerySafe" => { + #[allow(non_camel_case_types)] + struct ModuleQuerySafeSvc(pub Arc); + impl tonic::server::UnaryService + for ModuleQuerySafeSvc { + type Response = super::MsgModuleQuerySafeResponse; + 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 { + ::module_query_safe(&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 method = ModuleQuerySafeSvc(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/ibc.applications.interchain_accounts.host.v1.serde.rs b/src/prost/ibc.applications.interchain_accounts.host.v1.serde.rs index 8b52ba9..7bafbce 100644 --- a/src/prost/ibc.applications.interchain_accounts.host.v1.serde.rs +++ b/src/prost/ibc.applications.interchain_accounts.host.v1.serde.rs @@ -1,3 +1,225 @@ +impl serde::Serialize for MsgModuleQuerySafe { + #[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("ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafe", len)?; + if true { + struct_ser.serialize_field("signer", &self.signer)?; + } + if true { + struct_ser.serialize_field("requests", &self.requests)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgModuleQuerySafe { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "signer", + "requests", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Signer, + Requests, + } + 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 { + "signer" => Ok(GeneratedField::Signer), + "requests" => Ok(GeneratedField::Requests), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgModuleQuerySafe; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafe") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut signer__ = None; + let mut requests__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Signer => { + if signer__.is_some() { + return Err(serde::de::Error::duplicate_field("signer")); + } + signer__ = Some(map_.next_value()?); + } + GeneratedField::Requests => { + if requests__.is_some() { + return Err(serde::de::Error::duplicate_field("requests")); + } + requests__ = Some(map_.next_value()?); + } + } + } + Ok(MsgModuleQuerySafe { + signer: signer__.unwrap_or_default(), + requests: requests__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafe", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MsgModuleQuerySafeResponse { + #[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("ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafeResponse", len)?; + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("height", ::alloc::string::ToString::to_string(&self.height).as_str())?; + } + if true { + struct_ser.serialize_field("responses", &self.responses.iter().map(pbjson::private::base64::encode).collect::<::alloc::vec::Vec<_>>())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgModuleQuerySafeResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "height", + "responses", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Height, + Responses, + } + 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 { + "height" => Ok(GeneratedField::Height), + "responses" => Ok(GeneratedField::Responses), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgModuleQuerySafeResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafeResponse") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut height__ = None; + let mut responses__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Height => { + if height__.is_some() { + return Err(serde::de::Error::duplicate_field("height")); + } + height__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Responses => { + if responses__.is_some() { + return Err(serde::de::Error::duplicate_field("responses")); + } + responses__ = + Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::BytesDeserialize<_>>>()? + .into_iter().map(|x| x.0).collect()) + ; + } + } + } + Ok(MsgModuleQuerySafeResponse { + height: height__.unwrap_or_default(), + responses: responses__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafeResponse", FIELDS, GeneratedVisitor) + } +} impl serde::Serialize for MsgUpdateParams { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result @@ -449,3 +671,114 @@ impl<'de> serde::Deserialize<'de> for QueryParamsResponse { deserializer.deserialize_struct("ibc.applications.interchain_accounts.host.v1.QueryParamsResponse", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for QueryRequest { + #[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("ibc.applications.interchain_accounts.host.v1.QueryRequest", len)?; + if true { + struct_ser.serialize_field("path", &self.path)?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "path", + "data", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Path, + Data, + } + 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 { + "path" => Ok(GeneratedField::Path), + "data" => Ok(GeneratedField::Data), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.interchain_accounts.host.v1.QueryRequest") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut path__ = None; + let mut data__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Path => { + if path__.is_some() { + return Err(serde::de::Error::duplicate_field("path")); + } + path__ = Some(map_.next_value()?); + } + GeneratedField::Data => { + if data__.is_some() { + return Err(serde::de::Error::duplicate_field("data")); + } + data__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + } + } + Ok(QueryRequest { + path: path__.unwrap_or_default(), + data: data__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.applications.interchain_accounts.host.v1.QueryRequest", FIELDS, GeneratedVisitor) + } +} diff --git a/src/prost/ibc.applications.transfer.v1.rs b/src/prost/ibc.applications.transfer.v1.rs index 98eb521..faaad4d 100644 --- a/src/prost/ibc.applications.transfer.v1.rs +++ b/src/prost/ibc.applications.transfer.v1.rs @@ -1,27 +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)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct DenomTrace { - /// path defines the chain of port/channel identifiers used for tracing the - /// source of the fungible token. - #[prost(string, tag = "1")] - pub path: ::prost::alloc::string::String, - /// base denomination of the relayed fungible token. - #[prost(string, tag = "2")] - pub base_denom: ::prost::alloc::string::String, -} -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 { - "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. /// NOTE: To prevent a single token from being transferred, set the /// TransfersEnabled parameter to true and then set the bank module's SendEnabled @@ -48,6 +25,49 @@ impl ::prost::Name for Params { "/ibc.applications.transfer.v1.Params".into() } } +/// Forwarding defines a list of port ID, channel ID pairs determining the path +/// through which a packet must be forwarded, and an unwind boolean indicating if +/// the coin should be unwinded to its native chain before forwarding. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Forwarding { + /// optional unwinding for the token transfered + #[prost(bool, tag = "1")] + pub unwind: bool, + /// optional intermediate path through which packet will be forwarded + #[prost(message, repeated, tag = "2")] + pub hops: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for Forwarding { + const NAME: &'static str = "Forwarding"; + const PACKAGE: &'static str = "ibc.applications.transfer.v1"; + fn full_name() -> ::prost::alloc::string::String { + "ibc.applications.transfer.v1.Forwarding".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.Forwarding".into() + } +} +/// Hop defines a port ID, channel ID pair specifying where tokens must be forwarded +/// next in a multihop transfer. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Hop { + #[prost(string, tag = "1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub channel_id: ::prost::alloc::string::String, +} +impl ::prost::Name for Hop { + const NAME: &'static str = "Hop"; + const PACKAGE: &'static str = "ibc.applications.transfer.v1"; + fn full_name() -> ::prost::alloc::string::String { + "ibc.applications.transfer.v1.Hop".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v1.Hop".into() + } +} /// MsgTransfer defines a msg to transfer fungible tokens (i.e Coins) between /// ICS20 enabled chains. See ICS Spec here: /// @@ -60,7 +80,8 @@ pub struct MsgTransfer { /// the channel by which the packet will be sent #[prost(string, tag = "2")] pub source_channel: ::prost::alloc::string::String, - /// the tokens to be transferred + /// the token to be transferred. this field has been replaced by the tokens field. + #[deprecated] #[prost(message, optional, tag = "3")] pub token: ::core::option::Option< super::super::super::super::cosmos::base::v1beta1::Coin, @@ -84,6 +105,14 @@ pub struct MsgTransfer { /// optional memo #[prost(string, tag = "8")] pub memo: ::prost::alloc::string::String, + /// tokens to be transferred + #[prost(message, repeated, tag = "9")] + pub tokens: ::prost::alloc::vec::Vec< + super::super::super::super::cosmos::base::v1beta1::Coin, + >, + /// optional forwarding information + #[prost(message, optional, tag = "10")] + pub forwarding: ::core::option::Option, } impl ::prost::Name for MsgTransfer { const NAME: &'static str = "MsgTransfer"; @@ -516,87 +545,27 @@ pub mod msg_server { const NAME: &'static str = "ibc.applications.transfer.v1.Msg"; } } -/// QueryDenomTraceRequest is the request type for the Query/DenomTrace RPC -/// method +/// DenomTrace contains the base denomination for ICS20 fungible tokens and the +/// source tracing information path. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryDenomTraceRequest { - /// hash (in hex format) or denom (full denom with ibc prefix) of the denomination trace information. +pub struct DenomTrace { + /// path defines the chain of port/channel identifiers used for tracing the + /// source of the fungible token. #[prost(string, tag = "1")] - pub hash: ::prost::alloc::string::String, -} -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 { - "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 -/// method. -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryDenomTraceResponse { - /// denom_trace returns the requested denomination trace information. - #[prost(message, optional, tag = "1")] - pub denom_trace: ::core::option::Option, -} -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 { - "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 -/// method -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryDenomTracesRequest { - /// pagination defines an optional pagination for the request. - #[prost(message, optional, tag = "1")] - pub pagination: ::core::option::Option< - super::super::super::super::cosmos::base::query::v1beta1::PageRequest, - >, -} -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 { - "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 -/// method. -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryDenomTracesResponse { - /// denom_traces returns all denominations trace information. - #[prost(message, repeated, tag = "1")] - pub denom_traces: ::prost::alloc::vec::Vec, - /// pagination defines the pagination in the response. - #[prost(message, optional, tag = "2")] - pub pagination: ::core::option::Option< - super::super::super::super::cosmos::base::query::v1beta1::PageResponse, - >, + pub path: ::prost::alloc::string::String, + /// base denomination of the relayed fungible token. + #[prost(string, tag = "2")] + pub base_denom: ::prost::alloc::string::String, } -impl ::prost::Name for QueryDenomTracesResponse { - const NAME: &'static str = "QueryDenomTracesResponse"; +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 { - "ibc.applications.transfer.v1.QueryDenomTracesResponse".into() + "ibc.applications.transfer.v1.DenomTrace".into() } fn type_url() -> ::prost::alloc::string::String { - "/ibc.applications.transfer.v1.QueryDenomTracesResponse".into() + "/ibc.applications.transfer.v1.DenomTrace".into() } } /// QueryParamsRequest is the request type for the Query/Params RPC method. @@ -831,62 +800,6 @@ pub mod query_client { self.inner = self.inner.max_encoding_message_size(limit); self } - /// DenomTraces queries all denomination traces. - pub async fn denom_traces( - &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.applications.transfer.v1.Query/DenomTraces", - ); - let mut req = request.into_request(); - req.extensions_mut() - .insert( - GrpcMethod::new("ibc.applications.transfer.v1.Query", "DenomTraces"), - ); - self.inner.unary(req, path, codec).await - } - /// DenomTrace queries a denomination trace information. - pub async fn denom_trace( - &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.applications.transfer.v1.Query/DenomTrace", - ); - let mut req = request.into_request(); - req.extensions_mut() - .insert( - GrpcMethod::new("ibc.applications.transfer.v1.Query", "DenomTrace"), - ); - self.inner.unary(req, path, codec).await - } /// Params queries all parameters of the ibc-transfer module. pub async fn params( &mut self, @@ -1013,22 +926,6 @@ pub mod query_server { /// Generated trait containing gRPC methods that should be implemented for use with QueryServer. #[async_trait] pub trait Query: Send + Sync + 'static { - /// DenomTraces queries all denomination traces. - async fn denom_traces( - &self, - request: tonic::Request, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - >; - /// DenomTrace queries a denomination trace information. - async fn denom_trace( - &self, - request: tonic::Request, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - >; /// Params queries all parameters of the ibc-transfer module. async fn params( &self, @@ -1139,96 +1036,6 @@ pub mod query_server { } fn call(&mut self, req: http::Request) -> Self::Future { match req.uri().path() { - "/ibc.applications.transfer.v1.Query/DenomTraces" => { - #[allow(non_camel_case_types)] - struct DenomTracesSvc(pub Arc); - impl< - T: Query, - > tonic::server::UnaryService - for DenomTracesSvc { - type Response = super::QueryDenomTracesResponse; - 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 { - ::denom_traces(&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 method = DenomTracesSvc(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.applications.transfer.v1.Query/DenomTrace" => { - #[allow(non_camel_case_types)] - struct DenomTraceSvc(pub Arc); - impl< - T: Query, - > tonic::server::UnaryService - for DenomTraceSvc { - type Response = super::QueryDenomTraceResponse; - 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 { - ::denom_trace(&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 method = DenomTraceSvc(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.applications.transfer.v1.Query/Params" => { #[allow(non_camel_case_types)] struct ParamsSvc(pub Arc); @@ -1461,10 +1268,13 @@ pub struct Allocation { /// allow list of receivers, an empty allow list permits any receiver address #[prost(string, repeated, tag = "4")] pub allow_list: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, - /// allow list of packet data keys, an empty list prohibits all packet data keys; - /// a list only with "*" permits any packet data key + /// allow list of memo strings, an empty list prohibits all memo strings; + /// a list only with "*" permits any memo string #[prost(string, repeated, tag = "5")] pub allowed_packet_data: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Forwarding options that are allowed. + #[prost(message, repeated, tag = "6")] + pub allowed_forwarding: ::prost::alloc::vec::Vec, } impl ::prost::Name for Allocation { const NAME: &'static str = "Allocation"; @@ -1476,49 +1286,41 @@ impl ::prost::Name for Allocation { "/ibc.applications.transfer.v1.Allocation".into() } } -/// TransferAuthorization allows the grantee to spend up to spend_limit coins from -/// the granter's account for ibc transfer on a specific channel +/// AllowedForwarding defines which options are allowed for forwarding. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct TransferAuthorization { - /// port and channel amounts +pub struct AllowedForwarding { + /// a list of allowed source port ID/channel ID pairs through which the packet is allowed to be forwarded until final + /// destination #[prost(message, repeated, tag = "1")] - pub allocations: ::prost::alloc::vec::Vec, + pub hops: ::prost::alloc::vec::Vec, } -impl ::prost::Name for TransferAuthorization { - const NAME: &'static str = "TransferAuthorization"; +impl ::prost::Name for AllowedForwarding { + const NAME: &'static str = "AllowedForwarding"; const PACKAGE: &'static str = "ibc.applications.transfer.v1"; fn full_name() -> ::prost::alloc::string::String { - "ibc.applications.transfer.v1.TransferAuthorization".into() + "ibc.applications.transfer.v1.AllowedForwarding".into() } fn type_url() -> ::prost::alloc::string::String { - "/ibc.applications.transfer.v1.TransferAuthorization".into() + "/ibc.applications.transfer.v1.AllowedForwarding".into() } } -/// GenesisState defines the ibc-transfer genesis state +/// TransferAuthorization allows the grantee to spend up to spend_limit coins from +/// the granter's account for ibc transfer on a specific channel #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct GenesisState { - #[prost(string, tag = "1")] - pub port_id: ::prost::alloc::string::String, - #[prost(message, repeated, tag = "2")] - pub denom_traces: ::prost::alloc::vec::Vec, - #[prost(message, optional, tag = "3")] - pub params: ::core::option::Option, - /// total_escrowed contains the total amount of tokens escrowed - /// by the transfer module - #[prost(message, repeated, tag = "4")] - pub total_escrowed: ::prost::alloc::vec::Vec< - super::super::super::super::cosmos::base::v1beta1::Coin, - >, +pub struct TransferAuthorization { + /// port and channel amounts + #[prost(message, repeated, tag = "1")] + pub allocations: ::prost::alloc::vec::Vec, } -impl ::prost::Name for GenesisState { - const NAME: &'static str = "GenesisState"; +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 { - "ibc.applications.transfer.v1.GenesisState".into() + "ibc.applications.transfer.v1.TransferAuthorization".into() } fn type_url() -> ::prost::alloc::string::String { - "/ibc.applications.transfer.v1.GenesisState".into() + "/ibc.applications.transfer.v1.TransferAuthorization".into() } } diff --git a/src/prost/ibc.applications.transfer.v1.serde.rs b/src/prost/ibc.applications.transfer.v1.serde.rs index 2daf7aa..f30ecc9 100644 --- a/src/prost/ibc.applications.transfer.v1.serde.rs +++ b/src/prost/ibc.applications.transfer.v1.serde.rs @@ -21,6 +21,9 @@ impl serde::Serialize for Allocation { if true { len += 1; } + if true { + len += 1; + } let mut struct_ser = serializer.serialize_struct("ibc.applications.transfer.v1.Allocation", len)?; if true { struct_ser.serialize_field("sourcePort", &self.source_port)?; @@ -37,6 +40,9 @@ impl serde::Serialize for Allocation { if true { struct_ser.serialize_field("allowedPacketData", &self.allowed_packet_data)?; } + if true { + struct_ser.serialize_field("allowedForwarding", &self.allowed_forwarding)?; + } struct_ser.end() } } @@ -57,6 +63,8 @@ impl<'de> serde::Deserialize<'de> for Allocation { "allowList", "allowed_packet_data", "allowedPacketData", + "allowed_forwarding", + "allowedForwarding", ]; #[allow(clippy::enum_variant_names)] @@ -66,6 +74,7 @@ impl<'de> serde::Deserialize<'de> for Allocation { SpendLimit, AllowList, AllowedPacketData, + AllowedForwarding, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -92,6 +101,7 @@ impl<'de> serde::Deserialize<'de> for Allocation { "spendLimit" | "spend_limit" => Ok(GeneratedField::SpendLimit), "allowList" | "allow_list" => Ok(GeneratedField::AllowList), "allowedPacketData" | "allowed_packet_data" => Ok(GeneratedField::AllowedPacketData), + "allowedForwarding" | "allowed_forwarding" => Ok(GeneratedField::AllowedForwarding), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -116,6 +126,7 @@ impl<'de> serde::Deserialize<'de> for Allocation { let mut spend_limit__ = None; let mut allow_list__ = None; let mut allowed_packet_data__ = None; + let mut allowed_forwarding__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::SourcePort => { @@ -148,6 +159,12 @@ impl<'de> serde::Deserialize<'de> for Allocation { } allowed_packet_data__ = Some(map_.next_value()?); } + GeneratedField::AllowedForwarding => { + if allowed_forwarding__.is_some() { + return Err(serde::de::Error::duplicate_field("allowedForwarding")); + } + allowed_forwarding__ = Some(map_.next_value()?); + } } } Ok(Allocation { @@ -156,12 +173,104 @@ impl<'de> serde::Deserialize<'de> for Allocation { spend_limit: spend_limit__.unwrap_or_default(), allow_list: allow_list__.unwrap_or_default(), allowed_packet_data: allowed_packet_data__.unwrap_or_default(), + allowed_forwarding: allowed_forwarding__.unwrap_or_default(), }) } } deserializer.deserialize_struct("ibc.applications.transfer.v1.Allocation", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for AllowedForwarding { + #[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.applications.transfer.v1.AllowedForwarding", len)?; + if true { + struct_ser.serialize_field("hops", &self.hops)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for AllowedForwarding { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "hops", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Hops, + } + 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 { + "hops" => Ok(GeneratedField::Hops), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = AllowedForwarding; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.transfer.v1.AllowedForwarding") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut hops__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Hops => { + if hops__.is_some() { + return Err(serde::de::Error::duplicate_field("hops")); + } + hops__ = Some(map_.next_value()?); + } + } + } + Ok(AllowedForwarding { + hops: hops__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.applications.transfer.v1.AllowedForwarding", FIELDS, GeneratedVisitor) + } +} impl serde::Serialize for DenomTrace { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result @@ -271,7 +380,7 @@ impl<'de> serde::Deserialize<'de> for DenomTrace { deserializer.deserialize_struct("ibc.applications.transfer.v1.DenomTrace", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for GenesisState { +impl serde::Serialize for Forwarding { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -285,29 +394,125 @@ impl serde::Serialize for GenesisState { if true { len += 1; } + let mut struct_ser = serializer.serialize_struct("ibc.applications.transfer.v1.Forwarding", len)?; if true { - len += 1; + struct_ser.serialize_field("unwind", &self.unwind)?; } if true { - len += 1; + struct_ser.serialize_field("hops", &self.hops)?; } - let mut struct_ser = serializer.serialize_struct("ibc.applications.transfer.v1.GenesisState", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Forwarding { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "unwind", + "hops", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Unwind, + Hops, + } + 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 { + "unwind" => Ok(GeneratedField::Unwind), + "hops" => Ok(GeneratedField::Hops), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Forwarding; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.transfer.v1.Forwarding") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut unwind__ = None; + let mut hops__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Unwind => { + if unwind__.is_some() { + return Err(serde::de::Error::duplicate_field("unwind")); + } + unwind__ = Some(map_.next_value()?); + } + GeneratedField::Hops => { + if hops__.is_some() { + return Err(serde::de::Error::duplicate_field("hops")); + } + hops__ = Some(map_.next_value()?); + } + } + } + Ok(Forwarding { + unwind: unwind__.unwrap_or_default(), + hops: hops__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.applications.transfer.v1.Forwarding", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Hop { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; if true { - struct_ser.serialize_field("portId", &self.port_id)?; + len += 1; } if true { - struct_ser.serialize_field("denomTraces", &self.denom_traces)?; + len += 1; } - if let Some(v) = self.params.as_ref() { - struct_ser.serialize_field("params", v)?; + let mut struct_ser = serializer.serialize_struct("ibc.applications.transfer.v1.Hop", len)?; + if true { + struct_ser.serialize_field("portId", &self.port_id)?; } if true { - struct_ser.serialize_field("totalEscrowed", &self.total_escrowed)?; + struct_ser.serialize_field("channelId", &self.channel_id)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for GenesisState { +impl<'de> serde::Deserialize<'de> for Hop { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where @@ -316,19 +521,14 @@ impl<'de> serde::Deserialize<'de> for GenesisState { const FIELDS: &[&str] = &[ "port_id", "portId", - "denom_traces", - "denomTraces", - "params", - "total_escrowed", - "totalEscrowed", + "channel_id", + "channelId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { PortId, - DenomTraces, - Params, - TotalEscrowed, + ChannelId, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -351,9 +551,7 @@ impl<'de> serde::Deserialize<'de> for GenesisState { { match value { "portId" | "port_id" => Ok(GeneratedField::PortId), - "denomTraces" | "denom_traces" => Ok(GeneratedField::DenomTraces), - "params" => Ok(GeneratedField::Params), - "totalEscrowed" | "total_escrowed" => Ok(GeneratedField::TotalEscrowed), + "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -363,20 +561,18 @@ impl<'de> serde::Deserialize<'de> for GenesisState { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GenesisState; + type Value = Hop; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.applications.transfer.v1.GenesisState") + formatter.write_str("struct ibc.applications.transfer.v1.Hop") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { let mut port_id__ = None; - let mut denom_traces__ = None; - let mut params__ = None; - let mut total_escrowed__ = None; + let mut channel_id__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::PortId => { @@ -385,35 +581,21 @@ impl<'de> serde::Deserialize<'de> for GenesisState { } port_id__ = Some(map_.next_value()?); } - GeneratedField::DenomTraces => { - if denom_traces__.is_some() { - return Err(serde::de::Error::duplicate_field("denomTraces")); - } - denom_traces__ = Some(map_.next_value()?); - } - GeneratedField::Params => { - if params__.is_some() { - return Err(serde::de::Error::duplicate_field("params")); - } - params__ = map_.next_value()?; - } - GeneratedField::TotalEscrowed => { - if total_escrowed__.is_some() { - return Err(serde::de::Error::duplicate_field("totalEscrowed")); + GeneratedField::ChannelId => { + if channel_id__.is_some() { + return Err(serde::de::Error::duplicate_field("channelId")); } - total_escrowed__ = Some(map_.next_value()?); + channel_id__ = Some(map_.next_value()?); } } } - Ok(GenesisState { + Ok(Hop { port_id: port_id__.unwrap_or_default(), - denom_traces: denom_traces__.unwrap_or_default(), - params: params__, - total_escrowed: total_escrowed__.unwrap_or_default(), + channel_id: channel_id__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("ibc.applications.transfer.v1.GenesisState", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.applications.transfer.v1.Hop", FIELDS, GeneratedVisitor) } } impl serde::Serialize for MsgTransfer { @@ -448,6 +630,12 @@ impl serde::Serialize for MsgTransfer { if true { len += 1; } + if true { + len += 1; + } + if true { + len += 1; + } let mut struct_ser = serializer.serialize_struct("ibc.applications.transfer.v1.MsgTransfer", len)?; if true { struct_ser.serialize_field("sourcePort", &self.source_port)?; @@ -474,6 +662,12 @@ impl serde::Serialize for MsgTransfer { if true { struct_ser.serialize_field("memo", &self.memo)?; } + if true { + struct_ser.serialize_field("tokens", &self.tokens)?; + } + if let Some(v) = self.forwarding.as_ref() { + struct_ser.serialize_field("forwarding", v)?; + } struct_ser.end() } } @@ -496,6 +690,8 @@ impl<'de> serde::Deserialize<'de> for MsgTransfer { "timeout_timestamp", "timeoutTimestamp", "memo", + "tokens", + "forwarding", ]; #[allow(clippy::enum_variant_names)] @@ -508,6 +704,8 @@ impl<'de> serde::Deserialize<'de> for MsgTransfer { TimeoutHeight, TimeoutTimestamp, Memo, + Tokens, + Forwarding, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -537,6 +735,8 @@ impl<'de> serde::Deserialize<'de> for MsgTransfer { "timeoutHeight" | "timeout_height" => Ok(GeneratedField::TimeoutHeight), "timeoutTimestamp" | "timeout_timestamp" => Ok(GeneratedField::TimeoutTimestamp), "memo" => Ok(GeneratedField::Memo), + "tokens" => Ok(GeneratedField::Tokens), + "forwarding" => Ok(GeneratedField::Forwarding), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -564,6 +764,8 @@ impl<'de> serde::Deserialize<'de> for MsgTransfer { let mut timeout_height__ = None; let mut timeout_timestamp__ = None; let mut memo__ = None; + let mut tokens__ = None; + let mut forwarding__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::SourcePort => { @@ -616,6 +818,18 @@ impl<'de> serde::Deserialize<'de> for MsgTransfer { } memo__ = Some(map_.next_value()?); } + GeneratedField::Tokens => { + if tokens__.is_some() { + return Err(serde::de::Error::duplicate_field("tokens")); + } + tokens__ = Some(map_.next_value()?); + } + GeneratedField::Forwarding => { + if forwarding__.is_some() { + return Err(serde::de::Error::duplicate_field("forwarding")); + } + forwarding__ = map_.next_value()?; + } } } Ok(MsgTransfer { @@ -627,6 +841,8 @@ impl<'de> serde::Deserialize<'de> for MsgTransfer { timeout_height: timeout_height__, timeout_timestamp: timeout_timestamp__.unwrap_or_default(), memo: memo__.unwrap_or_default(), + tokens: tokens__.unwrap_or_default(), + forwarding: forwarding__, }) } } @@ -1198,389 +1414,6 @@ impl<'de> serde::Deserialize<'de> for QueryDenomHashResponse { deserializer.deserialize_struct("ibc.applications.transfer.v1.QueryDenomHashResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryDenomTraceRequest { - #[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.applications.transfer.v1.QueryDenomTraceRequest", len)?; - if true { - struct_ser.serialize_field("hash", &self.hash)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for QueryDenomTraceRequest { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "hash", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Hash, - } - 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 { - "hash" => Ok(GeneratedField::Hash), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryDenomTraceRequest; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.applications.transfer.v1.QueryDenomTraceRequest") - } - - fn visit_map(self, mut map_: V) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut hash__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Hash => { - if hash__.is_some() { - return Err(serde::de::Error::duplicate_field("hash")); - } - hash__ = Some(map_.next_value()?); - } - } - } - Ok(QueryDenomTraceRequest { - hash: hash__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("ibc.applications.transfer.v1.QueryDenomTraceRequest", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for QueryDenomTraceResponse { - #[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.applications.transfer.v1.QueryDenomTraceResponse", len)?; - if let Some(v) = self.denom_trace.as_ref() { - struct_ser.serialize_field("denomTrace", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for QueryDenomTraceResponse { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "denom_trace", - "denomTrace", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - DenomTrace, - } - 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 { - "denomTrace" | "denom_trace" => Ok(GeneratedField::DenomTrace), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryDenomTraceResponse; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.applications.transfer.v1.QueryDenomTraceResponse") - } - - fn visit_map(self, mut map_: V) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut denom_trace__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::DenomTrace => { - if denom_trace__.is_some() { - return Err(serde::de::Error::duplicate_field("denomTrace")); - } - denom_trace__ = map_.next_value()?; - } - } - } - Ok(QueryDenomTraceResponse { - denom_trace: denom_trace__, - }) - } - } - deserializer.deserialize_struct("ibc.applications.transfer.v1.QueryDenomTraceResponse", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for QueryDenomTracesRequest { - #[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.applications.transfer.v1.QueryDenomTracesRequest", len)?; - if let Some(v) = self.pagination.as_ref() { - struct_ser.serialize_field("pagination", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for QueryDenomTracesRequest { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "pagination", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Pagination, - } - 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 { - "pagination" => Ok(GeneratedField::Pagination), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryDenomTracesRequest; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.applications.transfer.v1.QueryDenomTracesRequest") - } - - fn visit_map(self, mut map_: V) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut pagination__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Pagination => { - if pagination__.is_some() { - return Err(serde::de::Error::duplicate_field("pagination")); - } - pagination__ = map_.next_value()?; - } - } - } - Ok(QueryDenomTracesRequest { - pagination: pagination__, - }) - } - } - deserializer.deserialize_struct("ibc.applications.transfer.v1.QueryDenomTracesRequest", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for QueryDenomTracesResponse { - #[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("ibc.applications.transfer.v1.QueryDenomTracesResponse", len)?; - if true { - struct_ser.serialize_field("denomTraces", &self.denom_traces)?; - } - if let Some(v) = self.pagination.as_ref() { - struct_ser.serialize_field("pagination", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for QueryDenomTracesResponse { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "denom_traces", - "denomTraces", - "pagination", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - DenomTraces, - Pagination, - } - 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 { - "denomTraces" | "denom_traces" => Ok(GeneratedField::DenomTraces), - "pagination" => Ok(GeneratedField::Pagination), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryDenomTracesResponse; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.applications.transfer.v1.QueryDenomTracesResponse") - } - - fn visit_map(self, mut map_: V) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut denom_traces__ = None; - let mut pagination__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::DenomTraces => { - if denom_traces__.is_some() { - return Err(serde::de::Error::duplicate_field("denomTraces")); - } - denom_traces__ = Some(map_.next_value()?); - } - GeneratedField::Pagination => { - if pagination__.is_some() { - return Err(serde::de::Error::duplicate_field("pagination")); - } - pagination__ = map_.next_value()?; - } - } - } - Ok(QueryDenomTracesResponse { - denom_traces: denom_traces__.unwrap_or_default(), - pagination: pagination__, - }) - } - } - deserializer.deserialize_struct("ibc.applications.transfer.v1.QueryDenomTracesResponse", FIELDS, GeneratedVisitor) - } -} impl serde::Serialize for QueryEscrowAddressRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result diff --git a/src/prost/ibc.applications.transfer.v2.rs b/src/prost/ibc.applications.transfer.v2.rs index a479bae..48d2d1a 100644 --- a/src/prost/ibc.applications.transfer.v2.rs +++ b/src/prost/ibc.applications.transfer.v2.rs @@ -1,4 +1,46 @@ // This file is @generated by prost-build. +/// Token defines a struct which represents a token to be transferred. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Token { + /// the token denomination + #[prost(message, optional, tag = "1")] + pub denom: ::core::option::Option, + /// the token amount to be transferred + #[prost(string, tag = "2")] + pub amount: ::prost::alloc::string::String, +} +impl ::prost::Name for Token { + const NAME: &'static str = "Token"; + const PACKAGE: &'static str = "ibc.applications.transfer.v2"; + fn full_name() -> ::prost::alloc::string::String { + "ibc.applications.transfer.v2.Token".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v2.Token".into() + } +} +/// Denom holds the base denom of a Token and a trace of the chains it was sent through. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Denom { + /// the base token denomination + #[prost(string, tag = "1")] + pub base: ::prost::alloc::string::String, + /// the trace of the token + #[prost(message, repeated, tag = "3")] + pub trace: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for Denom { + const NAME: &'static str = "Denom"; + const PACKAGE: &'static str = "ibc.applications.transfer.v2"; + fn full_name() -> ::prost::alloc::string::String { + "ibc.applications.transfer.v2.Denom".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v2.Denom".into() + } +} /// FungibleTokenPacketData defines a struct for the packet payload /// See FungibleTokenPacketData spec: /// @@ -31,3 +73,564 @@ impl ::prost::Name for FungibleTokenPacketData { "/ibc.applications.transfer.v2.FungibleTokenPacketData".into() } } +/// FungibleTokenPacketDataV2 defines a struct for the packet payload +/// See FungibleTokenPacketDataV2 spec: +/// +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FungibleTokenPacketDataV2 { + /// the tokens to be transferred + #[prost(message, repeated, tag = "1")] + pub tokens: ::prost::alloc::vec::Vec, + /// the sender address + #[prost(string, tag = "2")] + pub sender: ::prost::alloc::string::String, + /// the recipient address on the destination chain + #[prost(string, tag = "3")] + pub receiver: ::prost::alloc::string::String, + /// optional memo + #[prost(string, tag = "4")] + pub memo: ::prost::alloc::string::String, + /// optional forwarding information + #[prost(message, optional, tag = "5")] + pub forwarding: ::core::option::Option, +} +impl ::prost::Name for FungibleTokenPacketDataV2 { + const NAME: &'static str = "FungibleTokenPacketDataV2"; + const PACKAGE: &'static str = "ibc.applications.transfer.v2"; + fn full_name() -> ::prost::alloc::string::String { + "ibc.applications.transfer.v2.FungibleTokenPacketDataV2".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v2.FungibleTokenPacketDataV2".into() + } +} +/// ForwardingPacketData defines a list of port ID, channel ID pairs determining the path +/// through which a packet must be forwarded, and the destination memo string to be used in the +/// final destination of the tokens. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ForwardingPacketData { + /// optional memo consumed by final destination chain + #[prost(string, tag = "1")] + pub destination_memo: ::prost::alloc::string::String, + /// optional intermediate path through which packet will be forwarded. + #[prost(message, repeated, tag = "2")] + pub hops: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for ForwardingPacketData { + const NAME: &'static str = "ForwardingPacketData"; + const PACKAGE: &'static str = "ibc.applications.transfer.v2"; + fn full_name() -> ::prost::alloc::string::String { + "ibc.applications.transfer.v2.ForwardingPacketData".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v2.ForwardingPacketData".into() + } +} +/// QueryDenomRequest is the request type for the Query/Denom RPC +/// method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryDenomRequest { + /// hash (in hex format) or denom (full denom with ibc prefix) of the on chain denomination. + #[prost(string, tag = "1")] + pub hash: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryDenomRequest { + const NAME: &'static str = "QueryDenomRequest"; + const PACKAGE: &'static str = "ibc.applications.transfer.v2"; + fn full_name() -> ::prost::alloc::string::String { + "ibc.applications.transfer.v2.QueryDenomRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v2.QueryDenomRequest".into() + } +} +/// QueryDenomResponse is the response type for the Query/Denom RPC +/// method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryDenomResponse { + /// denom returns the requested denomination. + #[prost(message, optional, tag = "1")] + pub denom: ::core::option::Option, +} +impl ::prost::Name for QueryDenomResponse { + const NAME: &'static str = "QueryDenomResponse"; + const PACKAGE: &'static str = "ibc.applications.transfer.v2"; + fn full_name() -> ::prost::alloc::string::String { + "ibc.applications.transfer.v2.QueryDenomResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v2.QueryDenomResponse".into() + } +} +/// QueryDenomsRequest is the request type for the Query/Denoms RPC +/// method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryDenomsRequest { + /// pagination defines an optional pagination for the request. + #[prost(message, optional, tag = "1")] + pub pagination: ::core::option::Option< + super::super::super::super::cosmos::base::query::v1beta1::PageRequest, + >, +} +impl ::prost::Name for QueryDenomsRequest { + const NAME: &'static str = "QueryDenomsRequest"; + const PACKAGE: &'static str = "ibc.applications.transfer.v2"; + fn full_name() -> ::prost::alloc::string::String { + "ibc.applications.transfer.v2.QueryDenomsRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v2.QueryDenomsRequest".into() + } +} +/// QueryDenomsResponse is the response type for the Query/Denoms RPC +/// method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryDenomsResponse { + /// denoms returns all denominations. + #[prost(message, repeated, tag = "1")] + pub denoms: ::prost::alloc::vec::Vec, + /// pagination defines the pagination in the response. + #[prost(message, optional, tag = "2")] + pub pagination: ::core::option::Option< + super::super::super::super::cosmos::base::query::v1beta1::PageResponse, + >, +} +impl ::prost::Name for QueryDenomsResponse { + const NAME: &'static str = "QueryDenomsResponse"; + const PACKAGE: &'static str = "ibc.applications.transfer.v2"; + fn full_name() -> ::prost::alloc::string::String { + "ibc.applications.transfer.v2.QueryDenomsResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v2.QueryDenomsResponse".into() + } +} +/// Generated client implementations. +#[cfg(feature = "client")] +pub mod query_v2_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + /// QueryV2 provides defines the gRPC querier service for ics20-v2. + #[derive(Debug, Clone)] + pub struct QueryV2Client { + inner: tonic::client::Grpc, + } + impl QueryV2Client { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl QueryV2Client + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> QueryV2Client> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + QueryV2Client::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + /// Denoms queries all denominations + pub async fn denoms( + &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.applications.transfer.v2.QueryV2/Denoms", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("ibc.applications.transfer.v2.QueryV2", "Denoms"), + ); + self.inner.unary(req, path, codec).await + } + /// Denom queries a denomination + pub async fn denom( + &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.applications.transfer.v2.QueryV2/Denom", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("ibc.applications.transfer.v2.QueryV2", "Denom"), + ); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +#[cfg(feature = "server")] +pub mod query_v2_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with QueryV2Server. + #[async_trait] + pub trait QueryV2: Send + Sync + 'static { + /// Denoms queries all denominations + async fn denoms( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Denom queries a denomination + async fn denom( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + /// QueryV2 provides defines the gRPC querier service for ics20-v2. + #[derive(Debug)] + pub struct QueryV2Server { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl QueryV2Server { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for QueryV2Server + where + T: QueryV2, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/ibc.applications.transfer.v2.QueryV2/Denoms" => { + #[allow(non_camel_case_types)] + struct DenomsSvc(pub Arc); + impl< + T: QueryV2, + > tonic::server::UnaryService + for DenomsSvc { + type Response = super::QueryDenomsResponse; + 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 { + ::denoms(&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 method = DenomsSvc(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.applications.transfer.v2.QueryV2/Denom" => { + #[allow(non_camel_case_types)] + struct DenomSvc(pub Arc); + impl< + T: QueryV2, + > tonic::server::UnaryService + for DenomSvc { + type Response = super::QueryDenomResponse; + 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 { + ::denom(&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 method = DenomSvc(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( + http::Response::builder() + .status(200) + .header("grpc-status", tonic::Code::Unimplemented as i32) + .header( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ) + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for QueryV2Server { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl tonic::server::NamedService for QueryV2Server { + const NAME: &'static str = "ibc.applications.transfer.v2.QueryV2"; + } +} +/// GenesisState defines the ibc-transfer genesis state +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GenesisState { + #[prost(string, tag = "1")] + pub port_id: ::prost::alloc::string::String, + #[prost(message, repeated, tag = "2")] + pub denoms: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "3")] + pub params: ::core::option::Option, + /// total_escrowed contains the total amount of tokens escrowed + /// by the transfer module + #[prost(message, repeated, tag = "4")] + pub total_escrowed: ::prost::alloc::vec::Vec< + super::super::super::super::cosmos::base::v1beta1::Coin, + >, + /// forwarded_packets contains the forwarded packets stored as part of the + /// packet forwarding lifecycle + #[prost(message, repeated, tag = "5")] + pub forwarded_packets: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for GenesisState { + const NAME: &'static str = "GenesisState"; + const PACKAGE: &'static str = "ibc.applications.transfer.v2"; + fn full_name() -> ::prost::alloc::string::String { + "ibc.applications.transfer.v2.GenesisState".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v2.GenesisState".into() + } +} +/// ForwardedPacket defines the genesis type necessary to retrieve and store forwarded packets. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ForwardedPacket { + #[prost(message, optional, tag = "1")] + pub forward_key: ::core::option::Option< + super::super::super::core::channel::v1::PacketId, + >, + #[prost(message, optional, tag = "2")] + pub packet: ::core::option::Option, +} +impl ::prost::Name for ForwardedPacket { + const NAME: &'static str = "ForwardedPacket"; + const PACKAGE: &'static str = "ibc.applications.transfer.v2"; + fn full_name() -> ::prost::alloc::string::String { + "ibc.applications.transfer.v2.ForwardedPacket".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v2.ForwardedPacket".into() + } +} diff --git a/src/prost/ibc.applications.transfer.v2.serde.rs b/src/prost/ibc.applications.transfer.v2.serde.rs index 251c80e..24cfb6f 100644 --- a/src/prost/ibc.applications.transfer.v2.serde.rs +++ b/src/prost/ibc.applications.transfer.v2.serde.rs @@ -1,3 +1,329 @@ +impl serde::Serialize for Denom { + #[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("ibc.applications.transfer.v2.Denom", len)?; + if true { + struct_ser.serialize_field("base", &self.base)?; + } + if true { + struct_ser.serialize_field("trace", &self.trace)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Denom { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "base", + "trace", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Base, + Trace, + } + 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 { + "base" => Ok(GeneratedField::Base), + "trace" => Ok(GeneratedField::Trace), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Denom; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.transfer.v2.Denom") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut base__ = None; + let mut trace__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Base => { + if base__.is_some() { + return Err(serde::de::Error::duplicate_field("base")); + } + base__ = Some(map_.next_value()?); + } + GeneratedField::Trace => { + if trace__.is_some() { + return Err(serde::de::Error::duplicate_field("trace")); + } + trace__ = Some(map_.next_value()?); + } + } + } + Ok(Denom { + base: base__.unwrap_or_default(), + trace: trace__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.applications.transfer.v2.Denom", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ForwardedPacket { + #[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("ibc.applications.transfer.v2.ForwardedPacket", len)?; + if let Some(v) = self.forward_key.as_ref() { + struct_ser.serialize_field("forwardKey", v)?; + } + if let Some(v) = self.packet.as_ref() { + struct_ser.serialize_field("packet", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ForwardedPacket { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "forward_key", + "forwardKey", + "packet", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ForwardKey, + Packet, + } + 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 { + "forwardKey" | "forward_key" => Ok(GeneratedField::ForwardKey), + "packet" => Ok(GeneratedField::Packet), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ForwardedPacket; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.transfer.v2.ForwardedPacket") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut forward_key__ = None; + let mut packet__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ForwardKey => { + if forward_key__.is_some() { + return Err(serde::de::Error::duplicate_field("forwardKey")); + } + forward_key__ = map_.next_value()?; + } + GeneratedField::Packet => { + if packet__.is_some() { + return Err(serde::de::Error::duplicate_field("packet")); + } + packet__ = map_.next_value()?; + } + } + } + Ok(ForwardedPacket { + forward_key: forward_key__, + packet: packet__, + }) + } + } + deserializer.deserialize_struct("ibc.applications.transfer.v2.ForwardedPacket", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ForwardingPacketData { + #[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("ibc.applications.transfer.v2.ForwardingPacketData", len)?; + if true { + struct_ser.serialize_field("destinationMemo", &self.destination_memo)?; + } + if true { + struct_ser.serialize_field("hops", &self.hops)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ForwardingPacketData { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "destination_memo", + "destinationMemo", + "hops", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + DestinationMemo, + Hops, + } + 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 { + "destinationMemo" | "destination_memo" => Ok(GeneratedField::DestinationMemo), + "hops" => Ok(GeneratedField::Hops), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ForwardingPacketData; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.transfer.v2.ForwardingPacketData") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut destination_memo__ = None; + let mut hops__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::DestinationMemo => { + if destination_memo__.is_some() { + return Err(serde::de::Error::duplicate_field("destinationMemo")); + } + destination_memo__ = Some(map_.next_value()?); + } + GeneratedField::Hops => { + if hops__.is_some() { + return Err(serde::de::Error::duplicate_field("hops")); + } + hops__ = Some(map_.next_value()?); + } + } + } + Ok(ForwardingPacketData { + destination_memo: destination_memo__.unwrap_or_default(), + hops: hops__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.applications.transfer.v2.ForwardingPacketData", FIELDS, GeneratedVisitor) + } +} impl serde::Serialize for FungibleTokenPacketData { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result @@ -157,3 +483,813 @@ impl<'de> serde::Deserialize<'de> for FungibleTokenPacketData { deserializer.deserialize_struct("ibc.applications.transfer.v2.FungibleTokenPacketData", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for FungibleTokenPacketDataV2 { + #[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; + } + let mut struct_ser = serializer.serialize_struct("ibc.applications.transfer.v2.FungibleTokenPacketDataV2", len)?; + if true { + struct_ser.serialize_field("tokens", &self.tokens)?; + } + if true { + struct_ser.serialize_field("sender", &self.sender)?; + } + if true { + struct_ser.serialize_field("receiver", &self.receiver)?; + } + if true { + struct_ser.serialize_field("memo", &self.memo)?; + } + if let Some(v) = self.forwarding.as_ref() { + struct_ser.serialize_field("forwarding", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for FungibleTokenPacketDataV2 { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "tokens", + "sender", + "receiver", + "memo", + "forwarding", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Tokens, + Sender, + Receiver, + Memo, + Forwarding, + } + 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 { + "tokens" => Ok(GeneratedField::Tokens), + "sender" => Ok(GeneratedField::Sender), + "receiver" => Ok(GeneratedField::Receiver), + "memo" => Ok(GeneratedField::Memo), + "forwarding" => Ok(GeneratedField::Forwarding), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = FungibleTokenPacketDataV2; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.transfer.v2.FungibleTokenPacketDataV2") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut tokens__ = None; + let mut sender__ = None; + let mut receiver__ = None; + let mut memo__ = None; + let mut forwarding__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Tokens => { + if tokens__.is_some() { + return Err(serde::de::Error::duplicate_field("tokens")); + } + tokens__ = Some(map_.next_value()?); + } + GeneratedField::Sender => { + if sender__.is_some() { + return Err(serde::de::Error::duplicate_field("sender")); + } + sender__ = Some(map_.next_value()?); + } + GeneratedField::Receiver => { + if receiver__.is_some() { + return Err(serde::de::Error::duplicate_field("receiver")); + } + receiver__ = Some(map_.next_value()?); + } + GeneratedField::Memo => { + if memo__.is_some() { + return Err(serde::de::Error::duplicate_field("memo")); + } + memo__ = Some(map_.next_value()?); + } + GeneratedField::Forwarding => { + if forwarding__.is_some() { + return Err(serde::de::Error::duplicate_field("forwarding")); + } + forwarding__ = map_.next_value()?; + } + } + } + Ok(FungibleTokenPacketDataV2 { + tokens: tokens__.unwrap_or_default(), + sender: sender__.unwrap_or_default(), + receiver: receiver__.unwrap_or_default(), + memo: memo__.unwrap_or_default(), + forwarding: forwarding__, + }) + } + } + deserializer.deserialize_struct("ibc.applications.transfer.v2.FungibleTokenPacketDataV2", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for GenesisState { + #[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; + } + let mut struct_ser = serializer.serialize_struct("ibc.applications.transfer.v2.GenesisState", len)?; + if true { + struct_ser.serialize_field("portId", &self.port_id)?; + } + if true { + struct_ser.serialize_field("denoms", &self.denoms)?; + } + if let Some(v) = self.params.as_ref() { + struct_ser.serialize_field("params", v)?; + } + if true { + struct_ser.serialize_field("totalEscrowed", &self.total_escrowed)?; + } + if true { + struct_ser.serialize_field("forwardedPackets", &self.forwarded_packets)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for GenesisState { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "port_id", + "portId", + "denoms", + "params", + "total_escrowed", + "totalEscrowed", + "forwarded_packets", + "forwardedPackets", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + PortId, + Denoms, + Params, + TotalEscrowed, + ForwardedPackets, + } + 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), + "denoms" => Ok(GeneratedField::Denoms), + "params" => Ok(GeneratedField::Params), + "totalEscrowed" | "total_escrowed" => Ok(GeneratedField::TotalEscrowed), + "forwardedPackets" | "forwarded_packets" => Ok(GeneratedField::ForwardedPackets), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GenesisState; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.transfer.v2.GenesisState") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut port_id__ = None; + let mut denoms__ = None; + let mut params__ = None; + let mut total_escrowed__ = None; + let mut forwarded_packets__ = 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::Denoms => { + if denoms__.is_some() { + return Err(serde::de::Error::duplicate_field("denoms")); + } + denoms__ = Some(map_.next_value()?); + } + GeneratedField::Params => { + if params__.is_some() { + return Err(serde::de::Error::duplicate_field("params")); + } + params__ = map_.next_value()?; + } + GeneratedField::TotalEscrowed => { + if total_escrowed__.is_some() { + return Err(serde::de::Error::duplicate_field("totalEscrowed")); + } + total_escrowed__ = Some(map_.next_value()?); + } + GeneratedField::ForwardedPackets => { + if forwarded_packets__.is_some() { + return Err(serde::de::Error::duplicate_field("forwardedPackets")); + } + forwarded_packets__ = Some(map_.next_value()?); + } + } + } + Ok(GenesisState { + port_id: port_id__.unwrap_or_default(), + denoms: denoms__.unwrap_or_default(), + params: params__, + total_escrowed: total_escrowed__.unwrap_or_default(), + forwarded_packets: forwarded_packets__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.applications.transfer.v2.GenesisState", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for QueryDenomRequest { + #[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.applications.transfer.v2.QueryDenomRequest", len)?; + if true { + struct_ser.serialize_field("hash", &self.hash)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryDenomRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "hash", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Hash, + } + 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 { + "hash" => Ok(GeneratedField::Hash), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryDenomRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.transfer.v2.QueryDenomRequest") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut hash__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Hash => { + if hash__.is_some() { + return Err(serde::de::Error::duplicate_field("hash")); + } + hash__ = Some(map_.next_value()?); + } + } + } + Ok(QueryDenomRequest { + hash: hash__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.applications.transfer.v2.QueryDenomRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for QueryDenomResponse { + #[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.applications.transfer.v2.QueryDenomResponse", len)?; + if let Some(v) = self.denom.as_ref() { + struct_ser.serialize_field("denom", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryDenomResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "denom", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Denom, + } + 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 { + "denom" => Ok(GeneratedField::Denom), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryDenomResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.transfer.v2.QueryDenomResponse") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut denom__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Denom => { + if denom__.is_some() { + return Err(serde::de::Error::duplicate_field("denom")); + } + denom__ = map_.next_value()?; + } + } + } + Ok(QueryDenomResponse { + denom: denom__, + }) + } + } + deserializer.deserialize_struct("ibc.applications.transfer.v2.QueryDenomResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for QueryDenomsRequest { + #[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.applications.transfer.v2.QueryDenomsRequest", len)?; + if let Some(v) = self.pagination.as_ref() { + struct_ser.serialize_field("pagination", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryDenomsRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "pagination", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Pagination, + } + 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 { + "pagination" => Ok(GeneratedField::Pagination), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryDenomsRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.transfer.v2.QueryDenomsRequest") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut pagination__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Pagination => { + if pagination__.is_some() { + return Err(serde::de::Error::duplicate_field("pagination")); + } + pagination__ = map_.next_value()?; + } + } + } + Ok(QueryDenomsRequest { + pagination: pagination__, + }) + } + } + deserializer.deserialize_struct("ibc.applications.transfer.v2.QueryDenomsRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for QueryDenomsResponse { + #[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("ibc.applications.transfer.v2.QueryDenomsResponse", len)?; + if true { + struct_ser.serialize_field("denoms", &self.denoms)?; + } + if let Some(v) = self.pagination.as_ref() { + struct_ser.serialize_field("pagination", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryDenomsResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "denoms", + "pagination", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Denoms, + Pagination, + } + 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 { + "denoms" => Ok(GeneratedField::Denoms), + "pagination" => Ok(GeneratedField::Pagination), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryDenomsResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.transfer.v2.QueryDenomsResponse") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut denoms__ = None; + let mut pagination__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Denoms => { + if denoms__.is_some() { + return Err(serde::de::Error::duplicate_field("denoms")); + } + denoms__ = Some(map_.next_value()?); + } + GeneratedField::Pagination => { + if pagination__.is_some() { + return Err(serde::de::Error::duplicate_field("pagination")); + } + pagination__ = map_.next_value()?; + } + } + } + Ok(QueryDenomsResponse { + denoms: denoms__.unwrap_or_default(), + pagination: pagination__, + }) + } + } + deserializer.deserialize_struct("ibc.applications.transfer.v2.QueryDenomsResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Token { + #[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("ibc.applications.transfer.v2.Token", len)?; + if let Some(v) = self.denom.as_ref() { + struct_ser.serialize_field("denom", v)?; + } + if true { + struct_ser.serialize_field("amount", &self.amount)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Token { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "denom", + "amount", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Denom, + Amount, + } + 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 { + "denom" => Ok(GeneratedField::Denom), + "amount" => Ok(GeneratedField::Amount), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Token; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.applications.transfer.v2.Token") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut denom__ = None; + let mut amount__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Denom => { + if denom__.is_some() { + return Err(serde::de::Error::duplicate_field("denom")); + } + denom__ = map_.next_value()?; + } + GeneratedField::Amount => { + if amount__.is_some() { + return Err(serde::de::Error::duplicate_field("amount")); + } + amount__ = Some(map_.next_value()?); + } + } + } + Ok(Token { + denom: denom__, + amount: amount__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.applications.transfer.v2.Token", FIELDS, GeneratedVisitor) + } +} diff --git a/src/prost/ibc.core.channel.v1.rs b/src/prost/ibc.core.channel.v1.rs index 684f59b..0748b2c 100644 --- a/src/prost/ibc.core.channel.v1.rs +++ b/src/prost/ibc.core.channel.v1.rs @@ -178,7 +178,7 @@ impl ::prost::Name for PacketState { "/ibc.core.channel.v1.PacketState".into() } } -/// PacketId is an identifer for a unique Packet +/// PacketId is an identifier for a unique Packet /// Source chains refer to packets by source port/channel /// Destination chains refer to packets by destination port/channel #[allow(clippy::derive_partial_eq_without_eq)] @@ -1188,7 +1188,7 @@ impl ::prost::Name for MsgChannelUpgradeTimeout { "/ibc.core.channel.v1.MsgChannelUpgradeTimeout".into() } } -/// MsgChannelUpgradeTimeoutRepsonse defines the MsgChannelUpgradeTimeout response type +/// MsgChannelUpgradeTimeoutResponse defines the MsgChannelUpgradeTimeout response type #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, Copy, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeTimeoutResponse {} diff --git a/src/prost/ibc.core.client.v1.rs b/src/prost/ibc.core.client.v1.rs index c7176a4..996d217 100644 --- a/src/prost/ibc.core.client.v1.rs +++ b/src/prost/ibc.core.client.v1.rs @@ -79,6 +79,9 @@ impl ::prost::Name for ClientConsensusStates { /// breaking changes In these cases, the RevisionNumber is incremented so that /// height continues to be monitonically increasing even as the RevisionHeight /// gets reset +/// +/// Please note that json tags for generated Go code are overridden to explicitly exclude the omitempty jsontag. +/// This enforces the Go json marshaller to always emit zero values for both revision_number and revision_height. #[derive(Eq, PartialOrd, Ord)] #[cfg_attr( all(feature = "json-schema", feature = "serde"), @@ -124,75 +127,6 @@ impl ::prost::Name for Params { "/ibc.core.client.v1.Params".into() } } -/// ClientUpdateProposal is a legacy governance proposal. If it passes, the substitute -/// client's latest consensus state is copied over to the subject client. The proposal -/// handler may fail if the subject and the substitute do not match in client and -/// chain parameters (with exception to latest height, frozen height, and chain-id). -/// -/// Deprecated: Please use MsgRecoverClient in favour of this message type. -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ClientUpdateProposal { - /// the title of the update proposal - #[prost(string, tag = "1")] - pub title: ::prost::alloc::string::String, - /// the description of the proposal - #[prost(string, tag = "2")] - pub description: ::prost::alloc::string::String, - /// the client identifier for the client to be updated if the proposal passes - #[prost(string, tag = "3")] - pub subject_client_id: ::prost::alloc::string::String, - /// the substitute client identifier for the client standing in for the subject - /// client - #[prost(string, tag = "4")] - pub substitute_client_id: ::prost::alloc::string::String, -} -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 { - "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 -/// upgrade. -/// -/// Deprecated: Please use MsgIBCSoftwareUpgrade in favour of this message type. -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct UpgradeProposal { - #[prost(string, tag = "1")] - pub title: ::prost::alloc::string::String, - #[prost(string, tag = "2")] - pub description: ::prost::alloc::string::String, - #[prost(message, optional, tag = "3")] - pub plan: ::core::option::Option< - super::super::super::super::cosmos::upgrade::v1beta1::Plan, - >, - /// An UpgradedClientState must be provided to perform an IBC breaking upgrade. - /// This will make the chain commit to the correct upgraded (self) client state - /// before the upgrade occurs, so that connecting chains can verify that the - /// new upgraded client is valid by verifying a proof on the previous version - /// of the chain. This will allow IBC connections to persist smoothly across - /// planned chain upgrades - #[prost(message, optional, tag = "4")] - pub upgraded_client_state: ::core::option::Option< - super::super::super::super::google::protobuf::Any, - >, -} -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 { - "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. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -227,8 +161,8 @@ impl ::prost::Name for GenesisState { "/ibc.core.client.v1.GenesisState".into() } } -/// GenesisMetadata defines the genesis type for metadata that clients may return -/// with ExportMetadata +/// GenesisMetadata defines the genesis type for metadata that will be used +/// to export all client store keys that are not client or consensus states. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct GenesisMetadata { @@ -300,8 +234,11 @@ impl ::prost::Name for MsgCreateClient { } /// MsgCreateClientResponse defines the Msg/CreateClient response type. #[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, Copy, PartialEq, ::prost::Message)] -pub struct MsgCreateClientResponse {} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgCreateClientResponse { + #[prost(string, tag = "1")] + pub client_id: ::prost::alloc::string::String, +} impl ::prost::Name for MsgCreateClientResponse { const NAME: &'static str = "MsgCreateClientResponse"; const PACKAGE: &'static str = "ibc.core.client.v1"; @@ -1432,7 +1369,7 @@ pub struct QueryConsensusStateRequest { /// consensus state revision height #[prost(uint64, tag = "3")] pub revision_height: u64, - /// latest_height overrrides the height field and queries the latest stored + /// latest_height overrides the height field and queries the latest stored /// ConsensusState #[prost(bool, tag = "4")] pub latest_height: bool, @@ -1713,6 +1650,60 @@ impl ::prost::Name for QueryUpgradedConsensusStateResponse { "/ibc.core.client.v1.QueryUpgradedConsensusStateResponse".into() } } +/// QueryVerifyMembershipRequest is the request type for the Query/VerifyMembership RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryVerifyMembershipRequest { + /// client unique identifier. + #[prost(string, tag = "1")] + pub client_id: ::prost::alloc::string::String, + /// the proof to be verified by the client. + #[prost(bytes = "vec", tag = "2")] + pub proof: ::prost::alloc::vec::Vec, + /// the height of the commitment root at which the proof is verified. + #[prost(message, optional, tag = "3")] + pub proof_height: ::core::option::Option, + /// the value which is proven. + #[prost(bytes = "vec", tag = "5")] + pub value: ::prost::alloc::vec::Vec, + /// optional time delay + #[prost(uint64, tag = "6")] + pub time_delay: u64, + /// optional block delay + #[prost(uint64, tag = "7")] + pub block_delay: u64, + /// the commitment key path. + #[prost(message, optional, tag = "8")] + pub merkle_path: ::core::option::Option, +} +impl ::prost::Name for QueryVerifyMembershipRequest { + const NAME: &'static str = "QueryVerifyMembershipRequest"; + const PACKAGE: &'static str = "ibc.core.client.v1"; + fn full_name() -> ::prost::alloc::string::String { + "ibc.core.client.v1.QueryVerifyMembershipRequest".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryVerifyMembershipRequest".into() + } +} +/// QueryVerifyMembershipResponse is the response type for the Query/VerifyMembership RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct QueryVerifyMembershipResponse { + /// boolean indicating success or failure of proof verification. + #[prost(bool, tag = "1")] + pub success: bool, +} +impl ::prost::Name for QueryVerifyMembershipResponse { + const NAME: &'static str = "QueryVerifyMembershipResponse"; + const PACKAGE: &'static str = "ibc.core.client.v1"; + fn full_name() -> ::prost::alloc::string::String { + "ibc.core.client.v1.QueryVerifyMembershipResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryVerifyMembershipResponse".into() + } +} /// Generated client implementations. #[cfg(feature = "client")] pub mod query_client { @@ -2042,6 +2033,32 @@ pub mod query_client { ); self.inner.unary(req, path, codec).await } + /// VerifyMembership queries an IBC light client for proof verification of a value at a given key path. + pub async fn verify_membership( + &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/VerifyMembership", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("ibc.core.client.v1.Query", "VerifyMembership")); + self.inner.unary(req, path, codec).await + } } } /// Generated server implementations. @@ -2126,6 +2143,14 @@ pub mod query_server { tonic::Response, tonic::Status, >; + /// VerifyMembership queries an IBC light client for proof verification of a value at a given key path. + async fn verify_membership( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; } /// Query provides defines the gRPC querier service #[derive(Debug)] @@ -2618,6 +2643,51 @@ pub mod query_server { }; Box::pin(fut) } + "/ibc.core.client.v1.Query/VerifyMembership" => { + #[allow(non_camel_case_types)] + struct VerifyMembershipSvc(pub Arc); + impl< + T: Query, + > tonic::server::UnaryService + for VerifyMembershipSvc { + type Response = super::QueryVerifyMembershipResponse; + 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 { + ::verify_membership(&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 method = VerifyMembershipSvc(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/ibc.core.client.v1.serde.rs b/src/prost/ibc.core.client.v1.serde.rs index f3491f5..ed7b34e 100644 --- a/src/prost/ibc.core.client.v1.serde.rs +++ b/src/prost/ibc.core.client.v1.serde.rs @@ -108,150 +108,6 @@ impl<'de> serde::Deserialize<'de> for ClientConsensusStates { deserializer.deserialize_struct("ibc.core.client.v1.ClientConsensusStates", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ClientUpdateProposal { - #[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; - } - let mut struct_ser = serializer.serialize_struct("ibc.core.client.v1.ClientUpdateProposal", len)?; - if true { - struct_ser.serialize_field("title", &self.title)?; - } - if true { - struct_ser.serialize_field("description", &self.description)?; - } - if true { - struct_ser.serialize_field("subjectClientId", &self.subject_client_id)?; - } - if true { - struct_ser.serialize_field("substituteClientId", &self.substitute_client_id)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ClientUpdateProposal { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "title", - "description", - "subject_client_id", - "subjectClientId", - "substitute_client_id", - "substituteClientId", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Title, - Description, - SubjectClientId, - SubstituteClientId, - } - 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 { - "title" => Ok(GeneratedField::Title), - "description" => Ok(GeneratedField::Description), - "subjectClientId" | "subject_client_id" => Ok(GeneratedField::SubjectClientId), - "substituteClientId" | "substitute_client_id" => Ok(GeneratedField::SubstituteClientId), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ClientUpdateProposal; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.client.v1.ClientUpdateProposal") - } - - fn visit_map(self, mut map_: V) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut title__ = None; - let mut description__ = None; - let mut subject_client_id__ = None; - let mut substitute_client_id__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Title => { - if title__.is_some() { - return Err(serde::de::Error::duplicate_field("title")); - } - title__ = Some(map_.next_value()?); - } - GeneratedField::Description => { - if description__.is_some() { - return Err(serde::de::Error::duplicate_field("description")); - } - description__ = Some(map_.next_value()?); - } - GeneratedField::SubjectClientId => { - if subject_client_id__.is_some() { - return Err(serde::de::Error::duplicate_field("subjectClientId")); - } - subject_client_id__ = Some(map_.next_value()?); - } - GeneratedField::SubstituteClientId => { - if substitute_client_id__.is_some() { - return Err(serde::de::Error::duplicate_field("substituteClientId")); - } - substitute_client_id__ = Some(map_.next_value()?); - } - } - } - Ok(ClientUpdateProposal { - title: title__.unwrap_or_default(), - description: description__.unwrap_or_default(), - subject_client_id: subject_client_id__.unwrap_or_default(), - substitute_client_id: substitute_client_id__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("ibc.core.client.v1.ClientUpdateProposal", FIELDS, GeneratedVisitor) - } -} impl serde::Serialize for ConsensusStateWithHeight { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result @@ -1128,8 +984,14 @@ impl serde::Serialize for MsgCreateClientResponse { S: serde::Serializer, { use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("ibc.core.client.v1.MsgCreateClientResponse", len)?; + let mut len = 0; + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.client.v1.MsgCreateClientResponse", len)?; + if true { + struct_ser.serialize_field("clientId", &self.client_id)?; + } struct_ser.end() } } @@ -1140,10 +1002,13 @@ impl<'de> serde::Deserialize<'de> for MsgCreateClientResponse { D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "client_id", + "clientId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { + ClientId, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -1164,7 +1029,10 @@ impl<'de> serde::Deserialize<'de> for MsgCreateClientResponse { where E: serde::de::Error, { - Err(serde::de::Error::unknown_field(value, FIELDS)) + match value { + "clientId" | "client_id" => Ok(GeneratedField::ClientId), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -1182,10 +1050,19 @@ impl<'de> serde::Deserialize<'de> for MsgCreateClientResponse { where V: serde::de::MapAccess<'de>, { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; + let mut client_id__ = 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()?); + } + } } Ok(MsgCreateClientResponse { + client_id: client_id__.unwrap_or_default(), }) } } @@ -4322,7 +4199,7 @@ impl<'de> serde::Deserialize<'de> for QueryUpgradedConsensusStateResponse { deserializer.deserialize_struct("ibc.core.client.v1.QueryUpgradedConsensusStateResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for UpgradeProposal { +impl serde::Serialize for QueryVerifyMembershipRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -4342,42 +4219,74 @@ impl serde::Serialize for UpgradeProposal { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.client.v1.UpgradeProposal", len)?; if true { - struct_ser.serialize_field("title", &self.title)?; + len += 1; } if true { - struct_ser.serialize_field("description", &self.description)?; + len += 1; } - if let Some(v) = self.plan.as_ref() { - struct_ser.serialize_field("plan", v)?; + if true { + len += 1; } - if let Some(v) = self.upgraded_client_state.as_ref() { - struct_ser.serialize_field("upgradedClientState", v)?; + let mut struct_ser = serializer.serialize_struct("ibc.core.client.v1.QueryVerifyMembershipRequest", len)?; + if true { + struct_ser.serialize_field("clientId", &self.client_id)?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?; + } + if let Some(v) = self.proof_height.as_ref() { + struct_ser.serialize_field("proofHeight", v)?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("timeDelay", ::alloc::string::ToString::to_string(&self.time_delay).as_str())?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("blockDelay", ::alloc::string::ToString::to_string(&self.block_delay).as_str())?; + } + if let Some(v) = self.merkle_path.as_ref() { + struct_ser.serialize_field("merklePath", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for UpgradeProposal { +impl<'de> serde::Deserialize<'de> for QueryVerifyMembershipRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "title", - "description", - "plan", - "upgraded_client_state", - "upgradedClientState", + "client_id", + "clientId", + "proof", + "proof_height", + "proofHeight", + "value", + "time_delay", + "timeDelay", + "block_delay", + "blockDelay", + "merkle_path", + "merklePath", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Title, - Description, - Plan, - UpgradedClientState, + ClientId, + Proof, + ProofHeight, + Value, + TimeDelay, + BlockDelay, + MerklePath, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -4399,10 +4308,13 @@ impl<'de> serde::Deserialize<'de> for UpgradeProposal { E: serde::de::Error, { match value { - "title" => Ok(GeneratedField::Title), - "description" => Ok(GeneratedField::Description), - "plan" => Ok(GeneratedField::Plan), - "upgradedClientState" | "upgraded_client_state" => Ok(GeneratedField::UpgradedClientState), + "clientId" | "client_id" => Ok(GeneratedField::ClientId), + "proof" => Ok(GeneratedField::Proof), + "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight), + "value" => Ok(GeneratedField::Value), + "timeDelay" | "time_delay" => Ok(GeneratedField::TimeDelay), + "blockDelay" | "block_delay" => Ok(GeneratedField::BlockDelay), + "merklePath" | "merkle_path" => Ok(GeneratedField::MerklePath), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -4412,56 +4324,179 @@ impl<'de> serde::Deserialize<'de> for UpgradeProposal { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = UpgradeProposal; + type Value = QueryVerifyMembershipRequest; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.client.v1.UpgradeProposal") + formatter.write_str("struct ibc.core.client.v1.QueryVerifyMembershipRequest") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut title__ = None; - let mut description__ = None; - let mut plan__ = None; - let mut upgraded_client_state__ = None; + let mut client_id__ = None; + let mut proof__ = None; + let mut proof_height__ = None; + let mut value__ = None; + let mut time_delay__ = None; + let mut block_delay__ = None; + let mut merkle_path__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Title => { - if title__.is_some() { - return Err(serde::de::Error::duplicate_field("title")); + GeneratedField::ClientId => { + if client_id__.is_some() { + return Err(serde::de::Error::duplicate_field("clientId")); } - title__ = Some(map_.next_value()?); + client_id__ = Some(map_.next_value()?); } - GeneratedField::Description => { - if description__.is_some() { - return Err(serde::de::Error::duplicate_field("description")); + GeneratedField::Proof => { + if proof__.is_some() { + return Err(serde::de::Error::duplicate_field("proof")); } - description__ = Some(map_.next_value()?); + proof__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; } - GeneratedField::Plan => { - if plan__.is_some() { - return Err(serde::de::Error::duplicate_field("plan")); + GeneratedField::ProofHeight => { + if proof_height__.is_some() { + return Err(serde::de::Error::duplicate_field("proofHeight")); } - plan__ = map_.next_value()?; + proof_height__ = map_.next_value()?; } - GeneratedField::UpgradedClientState => { - if upgraded_client_state__.is_some() { - return Err(serde::de::Error::duplicate_field("upgradedClientState")); + GeneratedField::Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); } - upgraded_client_state__ = map_.next_value()?; + value__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::TimeDelay => { + if time_delay__.is_some() { + return Err(serde::de::Error::duplicate_field("timeDelay")); + } + time_delay__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::BlockDelay => { + if block_delay__.is_some() { + return Err(serde::de::Error::duplicate_field("blockDelay")); + } + block_delay__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::MerklePath => { + if merkle_path__.is_some() { + return Err(serde::de::Error::duplicate_field("merklePath")); + } + merkle_path__ = map_.next_value()?; } } } - Ok(UpgradeProposal { - title: title__.unwrap_or_default(), - description: description__.unwrap_or_default(), - plan: plan__, - upgraded_client_state: upgraded_client_state__, + Ok(QueryVerifyMembershipRequest { + client_id: client_id__.unwrap_or_default(), + proof: proof__.unwrap_or_default(), + proof_height: proof_height__, + value: value__.unwrap_or_default(), + time_delay: time_delay__.unwrap_or_default(), + block_delay: block_delay__.unwrap_or_default(), + merkle_path: merkle_path__, + }) + } + } + deserializer.deserialize_struct("ibc.core.client.v1.QueryVerifyMembershipRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for QueryVerifyMembershipResponse { + #[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.QueryVerifyMembershipResponse", len)?; + if true { + struct_ser.serialize_field("success", &self.success)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryVerifyMembershipResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "success", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Success, + } + 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 { + "success" => Ok(GeneratedField::Success), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryVerifyMembershipResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.client.v1.QueryVerifyMembershipResponse") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut success__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Success => { + if success__.is_some() { + return Err(serde::de::Error::duplicate_field("success")); + } + success__ = Some(map_.next_value()?); + } + } + } + Ok(QueryVerifyMembershipResponse { + success: success__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("ibc.core.client.v1.UpgradeProposal", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.client.v1.QueryVerifyMembershipResponse", FIELDS, GeneratedVisitor) } } diff --git a/src/prost/ibc.core.commitment.v1.rs b/src/prost/ibc.core.commitment.v1.rs index 77d2ca9..ad8941a 100644 --- a/src/prost/ibc.core.commitment.v1.rs +++ b/src/prost/ibc.core.commitment.v1.rs @@ -52,25 +52,6 @@ impl ::prost::Name for MerklePrefix { "/ibc.core.commitment.v1.MerklePrefix".into() } } -/// MerklePath is the path used to verify commitment proofs, which can be an -/// arbitrary structured object (defined by a commitment type). -/// MerklePath is represented from root-to-leaf -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MerklePath { - #[prost(string, repeated, tag = "1")] - pub key_path: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, -} -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 { - "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. /// It demonstrates membership or non-membership for an element or set of /// elements, verifiable in conjunction with a known commitment root. Proofs diff --git a/src/prost/ibc.core.commitment.v1.serde.rs b/src/prost/ibc.core.commitment.v1.serde.rs index 9173f7e..4c870ad 100644 --- a/src/prost/ibc.core.commitment.v1.serde.rs +++ b/src/prost/ibc.core.commitment.v1.serde.rs @@ -1,95 +1,3 @@ -impl serde::Serialize for MerklePath { - #[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.commitment.v1.MerklePath", len)?; - if true { - struct_ser.serialize_field("keyPath", &self.key_path)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for MerklePath { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "key_path", - "keyPath", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - KeyPath, - } - 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 { - "keyPath" | "key_path" => Ok(GeneratedField::KeyPath), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MerklePath; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.commitment.v1.MerklePath") - } - - fn visit_map(self, mut map_: V) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut key_path__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::KeyPath => { - if key_path__.is_some() { - return Err(serde::de::Error::duplicate_field("keyPath")); - } - key_path__ = Some(map_.next_value()?); - } - } - } - Ok(MerklePath { - key_path: key_path__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("ibc.core.commitment.v1.MerklePath", FIELDS, GeneratedVisitor) - } -} impl serde::Serialize for MerklePrefix { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result diff --git a/src/prost/ibc.core.commitment.v2.rs b/src/prost/ibc.core.commitment.v2.rs new file mode 100644 index 0000000..8a94d02 --- /dev/null +++ b/src/prost/ibc.core.commitment.v2.rs @@ -0,0 +1,20 @@ +// This file is @generated by prost-build. +/// MerklePath is the path used to verify commitment proofs, which can be an +/// arbitrary structured object (defined by a commitment type). +/// MerklePath is represented from root-to-leaf +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MerklePath { + #[prost(bytes = "vec", repeated, tag = "1")] + pub key_path: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, +} +impl ::prost::Name for MerklePath { + const NAME: &'static str = "MerklePath"; + const PACKAGE: &'static str = "ibc.core.commitment.v2"; + fn full_name() -> ::prost::alloc::string::String { + "ibc.core.commitment.v2.MerklePath".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.commitment.v2.MerklePath".into() + } +} diff --git a/src/prost/ibc.core.commitment.v2.serde.rs b/src/prost/ibc.core.commitment.v2.serde.rs new file mode 100644 index 0000000..ba3be00 --- /dev/null +++ b/src/prost/ibc.core.commitment.v2.serde.rs @@ -0,0 +1,95 @@ +impl serde::Serialize for MerklePath { + #[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.commitment.v2.MerklePath", len)?; + if true { + struct_ser.serialize_field("keyPath", &self.key_path.iter().map(pbjson::private::base64::encode).collect::<::alloc::vec::Vec<_>>())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MerklePath { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "key_path", + "keyPath", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + KeyPath, + } + 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 { + "keyPath" | "key_path" => Ok(GeneratedField::KeyPath), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MerklePath; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.commitment.v2.MerklePath") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut key_path__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::KeyPath => { + if key_path__.is_some() { + return Err(serde::de::Error::duplicate_field("keyPath")); + } + key_path__ = + Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::BytesDeserialize<_>>>()? + .into_iter().map(|x| x.0).collect()) + ; + } + } + } + Ok(MerklePath { + key_path: key_path__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.core.commitment.v2.MerklePath", FIELDS, GeneratedVisitor) + } +} diff --git a/src/prost/ibc.core.connection.v1.rs b/src/prost/ibc.core.connection.v1.rs index d26254d..042443e 100644 --- a/src/prost/ibc.core.connection.v1.rs +++ b/src/prost/ibc.core.connection.v1.rs @@ -143,7 +143,7 @@ impl ::prost::Name for ConnectionPaths { "/ibc.core.connection.v1.ConnectionPaths".into() } } -/// Version defines the versioning scheme used to negotiate the IBC verison in +/// Version defines the versioning scheme used to negotiate the IBC version in /// the connection handshake. #[cfg_attr( all(feature = "json-schema", feature = "serde"), @@ -304,6 +304,8 @@ pub struct MsgConnectionOpenTry { #[deprecated] #[prost(string, tag = "2")] pub previous_connection_id: ::prost::alloc::string::String, + /// Deprecated: this field is unused. + #[deprecated] #[prost(message, optional, tag = "3")] pub client_state: ::core::option::Option< super::super::super::super::google::protobuf::Any, @@ -316,21 +318,26 @@ pub struct MsgConnectionOpenTry { pub counterparty_versions: ::prost::alloc::vec::Vec, #[prost(message, optional, tag = "7")] pub proof_height: ::core::option::Option, - /// proof of the initialization the connection on Chain A: `UNITIALIZED -> + /// proof of the initialization the connection on Chain A: `UNINITIALIZED -> /// INIT` #[prost(bytes = "vec", tag = "8")] pub proof_init: ::prost::alloc::vec::Vec, - /// proof of client state included in message + /// Deprecated: this field is unused. + #[deprecated] #[prost(bytes = "vec", tag = "9")] pub proof_client: ::prost::alloc::vec::Vec, - /// proof of client consensus state + /// Deprecated: this field is unused. + #[deprecated] #[prost(bytes = "vec", tag = "10")] pub proof_consensus: ::prost::alloc::vec::Vec, + /// Deprecated: this field is unused. + #[deprecated] #[prost(message, optional, tag = "11")] pub consensus_height: ::core::option::Option, #[prost(string, tag = "12")] pub signer: ::prost::alloc::string::String, - /// optional proof data for host state machines that are unable to introspect their own consensus state + /// Deprecated: this field is unused. + #[deprecated] #[prost(bytes = "vec", tag = "13")] pub host_consensus_state_proof: ::prost::alloc::vec::Vec, } @@ -369,27 +376,34 @@ pub struct MsgConnectionOpenAck { pub counterparty_connection_id: ::prost::alloc::string::String, #[prost(message, optional, tag = "3")] pub version: ::core::option::Option, + /// Deprecated: this field is unused. + #[deprecated] #[prost(message, optional, tag = "4")] pub client_state: ::core::option::Option< super::super::super::super::google::protobuf::Any, >, #[prost(message, optional, tag = "5")] pub proof_height: ::core::option::Option, - /// proof of the initialization the connection on Chain B: `UNITIALIZED -> + /// proof of the initialization the connection on Chain B: `UNINITIALIZED -> /// TRYOPEN` #[prost(bytes = "vec", tag = "6")] pub proof_try: ::prost::alloc::vec::Vec, - /// proof of client state included in message + /// Deprecated: this field is unused. + #[deprecated] #[prost(bytes = "vec", tag = "7")] pub proof_client: ::prost::alloc::vec::Vec, - /// proof of client consensus state + /// Deprecated: this field is unused. + #[deprecated] #[prost(bytes = "vec", tag = "8")] pub proof_consensus: ::prost::alloc::vec::Vec, + /// Deprecated: this field is unused. + #[deprecated] #[prost(message, optional, tag = "9")] pub consensus_height: ::core::option::Option, #[prost(string, tag = "10")] pub signer: ::prost::alloc::string::String, - /// optional proof data for host state machines that are unable to introspect their own consensus state + /// Deprecated: this field is unused. + #[deprecated] #[prost(bytes = "vec", tag = "11")] pub host_consensus_state_proof: ::prost::alloc::vec::Vec, } diff --git a/src/prost/ibc.lightclients.tendermint.v1.rs b/src/prost/ibc.lightclients.tendermint.v1.rs index a1eb7a2..6135772 100644 --- a/src/prost/ibc.lightclients.tendermint.v1.rs +++ b/src/prost/ibc.lightclients.tendermint.v1.rs @@ -8,7 +8,7 @@ pub struct ClientState { pub chain_id: ::prost::alloc::string::String, #[prost(message, optional, tag = "2")] pub trust_level: ::core::option::Option, - /// duration of the period since the LastestTimestamp during which the + /// duration of the period since the LatestTimestamp during which the /// submitted headers are valid for upgrade #[prost(message, optional, tag = "3")] pub trusting_period: ::core::option::Option< diff --git a/src/prost/proto_descriptor.bin b/src/prost/proto_descriptor.bin index 7a44e26..af9418f 100644 Binary files a/src/prost/proto_descriptor.bin and b/src/prost/proto_descriptor.bin differ