From 4c4e09551fccc9b5121fad5aec8b1cc6416cf0c7 Mon Sep 17 00:00:00 2001 From: Luca Joss Date: Wed, 29 May 2024 13:58:33 +0200 Subject: [PATCH 1/3] Update ibc-go commit with ICS20-v2 changes --- src/IBC_GO_COMMIT | 2 +- src/prost/google.protobuf.rs | 57 +-- src/prost/google.protobuf.serde.rs | 30 +- src/prost/ibc.applications.fee.v1.rs | 4 +- ...pplications.interchain_accounts.host.v1.rs | 146 ++++++++ ...tions.interchain_accounts.host.v1.serde.rs | 333 ++++++++++++++++++ src/prost/ibc.applications.transfer.v1.rs | 9 +- .../ibc.applications.transfer.v1.serde.rs | 17 + src/prost/ibc.applications.transfer.v2.rs | 47 +++ .../ibc.applications.transfer.v2.serde.rs | 267 ++++++++++++++ src/prost/ibc.core.channel.v1.rs | 2 +- src/prost/ibc.core.client.v1.rs | 134 ++++++- src/prost/ibc.core.client.v1.serde.rs | 301 ++++++++++++++++ src/prost/ibc.core.connection.v1.rs | 6 +- src/prost/ibc.lightclients.tendermint.v1.rs | 2 +- src/prost/proto_descriptor.bin | Bin 762475 -> 767889 bytes 16 files changed, 1307 insertions(+), 50 deletions(-) diff --git a/src/IBC_GO_COMMIT b/src/IBC_GO_COMMIT index 8a6720b4..fa8ec6f6 100644 --- a/src/IBC_GO_COMMIT +++ b/src/IBC_GO_COMMIT @@ -1 +1 @@ -a4ef5360b49ad2118e1d68f25f13935162660e0b \ No newline at end of file +dcf6e340e31c40c828a6340836b3800640d30570 \ No newline at end of file diff --git a/src/prost/google.protobuf.rs b/src/prost/google.protobuf.rs index 3f43790e..5976a8b1 100644 --- a/src/prost/google.protobuf.rs +++ b/src/prost/google.protobuf.rs @@ -432,12 +432,12 @@ pub struct FieldDescriptorProto { /// If true, this is a proto3 "optional". When a proto3 field is optional, it /// tracks presence regardless of field type. /// - /// When proto3_optional is true, this field must 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 @@ -806,6 +806,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 @@ -945,6 +947,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. /// @@ -962,10 +968,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 @@ -1055,11 +1057,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 @@ -1715,8 +1725,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. @@ -1726,16 +1736,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, } } @@ -1935,7 +1945,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: @@ -2147,7 +2157,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, @@ -2155,10 +2164,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. @@ -2171,13 +2176,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. @@ -2187,13 +2190,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 4a8362c6..5a7056e1 100644 --- a/src/prost/google.protobuf.serde.rs +++ b/src/prost/google.protobuf.serde.rs @@ -725,13 +725,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) } @@ -747,13 +745,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; @@ -798,13 +794,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)), } } @@ -2471,8 +2465,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) } @@ -2485,8 +2479,8 @@ impl<'de> serde::Deserialize<'de> for feature_set::Utf8Validation { { const FIELDS: &[&str] = &[ "UTF8_VALIDATION_UNKNOWN", - "VERIFY", "NONE", + "VERIFY", ]; struct GeneratedVisitor; @@ -2528,8 +2522,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)), } } @@ -4451,6 +4445,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)?; @@ -4484,6 +4481,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)?; } @@ -4547,6 +4547,8 @@ impl<'de> serde::Deserialize<'de> for FileOptions { "javaGenericServices", "py_generic_services", "pyGenericServices", + "php_generic_services", + "phpGenericServices", "deprecated", "cc_enable_arenas", "ccEnableArenas", @@ -4581,6 +4583,7 @@ impl<'de> serde::Deserialize<'de> for FileOptions { CcGenericServices, JavaGenericServices, PyGenericServices, + PhpGenericServices, Deprecated, CcEnableArenas, ObjcClassPrefix, @@ -4623,6 +4626,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), @@ -4663,6 +4667,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; @@ -4736,6 +4741,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")); @@ -4815,6 +4826,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 9d798dce..1dcf4340 100644 --- a/src/prost/ibc.applications.fee.v1.rs +++ b/src/prost/ibc.applications.fee.v1.rs @@ -163,7 +163,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 @@ -910,7 +910,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, diff --git a/src/prost/ibc.applications.interchain_accounts.host.v1.rs b/src/prost/ibc.applications.interchain_accounts.host.v1.rs index 0cbc62ef..ff15d696 100644 --- a/src/prost/ibc.applications.interchain_accounts.host.v1.rs +++ b/src/prost/ibc.applications.interchain_accounts.host.v1.rs @@ -19,6 +19,29 @@ impl ::prost::Name for Params { ) } } +/// 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 { + ::prost::alloc::format!( + "ibc.applications.interchain_accounts.host.v1.{}", Self::NAME + ) + } +} /// MsgUpdateParams defines the payload for Msg/UpdateParams #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -54,6 +77,46 @@ impl ::prost::Name for MsgUpdateParamsResponse { ) } } +/// 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 { + ::prost::alloc::format!( + "ibc.applications.interchain_accounts.host.v1.{}", Self::NAME + ) + } +} +/// 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 { + ::prost::alloc::format!( + "ibc.applications.interchain_accounts.host.v1.{}", Self::NAME + ) + } +} /// Generated client implementations. #[cfg(feature = "client")] pub mod msg_client { @@ -172,6 +235,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. @@ -190,6 +284,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 +417,50 @@ 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 inner = inner.0; + 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 8b52ba9b..7bafbce9 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 70c3a6c7..7f371547 100644 --- a/src/prost/ibc.applications.transfer.v1.rs +++ b/src/prost/ibc.applications.transfer.v1.rs @@ -77,6 +77,11 @@ 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, + >, } impl ::prost::Name for MsgTransfer { const NAME: &'static str = "MsgTransfer"; @@ -1434,8 +1439,8 @@ 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>, } diff --git a/src/prost/ibc.applications.transfer.v1.serde.rs b/src/prost/ibc.applications.transfer.v1.serde.rs index 2daf7aae..e34731ee 100644 --- a/src/prost/ibc.applications.transfer.v1.serde.rs +++ b/src/prost/ibc.applications.transfer.v1.serde.rs @@ -448,6 +448,9 @@ impl serde::Serialize for MsgTransfer { 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 +477,9 @@ impl serde::Serialize for MsgTransfer { if true { struct_ser.serialize_field("memo", &self.memo)?; } + if true { + struct_ser.serialize_field("tokens", &self.tokens)?; + } struct_ser.end() } } @@ -496,6 +502,7 @@ impl<'de> serde::Deserialize<'de> for MsgTransfer { "timeout_timestamp", "timeoutTimestamp", "memo", + "tokens", ]; #[allow(clippy::enum_variant_names)] @@ -508,6 +515,7 @@ impl<'de> serde::Deserialize<'de> for MsgTransfer { TimeoutHeight, TimeoutTimestamp, Memo, + Tokens, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -537,6 +545,7 @@ 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), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -564,6 +573,7 @@ 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; while let Some(k) = map_.next_key()? { match k { GeneratedField::SourcePort => { @@ -616,6 +626,12 @@ 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()?); + } } } Ok(MsgTransfer { @@ -627,6 +643,7 @@ 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(), }) } } diff --git a/src/prost/ibc.applications.transfer.v2.rs b/src/prost/ibc.applications.transfer.v2.rs index 33fa7869..21fd44d9 100644 --- a/src/prost/ibc.applications.transfer.v2.rs +++ b/src/prost/ibc.applications.transfer.v2.rs @@ -27,3 +27,50 @@ impl ::prost::Name for FungibleTokenPacketData { ::prost::alloc::format!("ibc.applications.transfer.v2.{}", Self::NAME) } } +/// 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, +} +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 { + ::prost::alloc::format!("ibc.applications.transfer.v2.{}", Self::NAME) + } +} +/// 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 base token denomination to be transferred + #[prost(string, tag = "1")] + pub denom: ::prost::alloc::string::String, + /// the token amount to be transferred + #[prost(string, tag = "2")] + pub amount: ::prost::alloc::string::String, + /// the trace of the token + #[prost(string, repeated, tag = "3")] + pub trace: ::prost::alloc::vec::Vec<::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 { + ::prost::alloc::format!("ibc.applications.transfer.v2.{}", Self::NAME) + } +} diff --git a/src/prost/ibc.applications.transfer.v2.serde.rs b/src/prost/ibc.applications.transfer.v2.serde.rs index 251c80e2..c1e34b82 100644 --- a/src/prost/ibc.applications.transfer.v2.serde.rs +++ b/src/prost/ibc.applications.transfer.v2.serde.rs @@ -157,3 +157,270 @@ 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; + } + 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)?; + } + 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", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Tokens, + Sender, + Receiver, + Memo, + } + 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), + _ => 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; + 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()?); + } + } + } + Ok(FungibleTokenPacketDataV2 { + tokens: tokens__.unwrap_or_default(), + sender: sender__.unwrap_or_default(), + receiver: receiver__.unwrap_or_default(), + memo: memo__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.applications.transfer.v2.FungibleTokenPacketDataV2", 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; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.applications.transfer.v2.Token", len)?; + if true { + struct_ser.serialize_field("denom", &self.denom)?; + } + if true { + struct_ser.serialize_field("amount", &self.amount)?; + } + if true { + struct_ser.serialize_field("trace", &self.trace)?; + } + 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", + "trace", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Denom, + Amount, + 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 { + "denom" => Ok(GeneratedField::Denom), + "amount" => Ok(GeneratedField::Amount), + "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 = 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; + let mut trace__ = 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__ = Some(map_.next_value()?); + } + GeneratedField::Amount => { + if amount__.is_some() { + return Err(serde::de::Error::duplicate_field("amount")); + } + amount__ = Some(map_.next_value()?); + } + GeneratedField::Trace => { + if trace__.is_some() { + return Err(serde::de::Error::duplicate_field("trace")); + } + trace__ = Some(map_.next_value()?); + } + } + } + Ok(Token { + denom: denom__.unwrap_or_default(), + amount: amount__.unwrap_or_default(), + trace: trace__.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 53c79e71..1d2be6f3 100644 --- a/src/prost/ibc.core.channel.v1.rs +++ b/src/prost/ibc.core.channel.v1.rs @@ -162,7 +162,7 @@ impl ::prost::Name for PacketState { ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) } } -/// 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)] diff --git a/src/prost/ibc.core.client.v1.rs b/src/prost/ibc.core.client.v1.rs index fc33ec80..33ffa3fa 100644 --- a/src/prost/ibc.core.client.v1.rs +++ b/src/prost/ibc.core.client.v1.rs @@ -202,8 +202,8 @@ impl ::prost::Name for GenesisState { ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) } } -/// 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 { @@ -1364,7 +1364,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, @@ -1603,6 +1603,54 @@ impl ::prost::Name for QueryUpgradedConsensusStateResponse { ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) } } +/// 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 commitment key path. + #[prost(message, optional, tag = "4")] + pub merkle_path: ::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, +} +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 { + ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + } +} +/// QueryVerifyMembershipResponse is the response type for the Query/VerifyMembership RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, 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 { + ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + } +} /// Generated client implementations. #[cfg(feature = "client")] pub mod query_client { @@ -1932,6 +1980,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. @@ -2016,6 +2090,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)] @@ -2520,6 +2602,52 @@ 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 inner = inner.0; + 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 f3491f56..ef3244b0 100644 --- a/src/prost/ibc.core.client.v1.serde.rs +++ b/src/prost/ibc.core.client.v1.serde.rs @@ -4322,6 +4322,307 @@ impl<'de> serde::Deserialize<'de> for QueryUpgradedConsensusStateResponse { deserializer.deserialize_struct("ibc.core.client.v1.QueryUpgradedConsensusStateResponse", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for QueryVerifyMembershipRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + 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 let Some(v) = self.merkle_path.as_ref() { + struct_ser.serialize_field("merklePath", 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())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryVerifyMembershipRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "client_id", + "clientId", + "proof", + "proof_height", + "proofHeight", + "merkle_path", + "merklePath", + "value", + "time_delay", + "timeDelay", + "block_delay", + "blockDelay", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ClientId, + Proof, + ProofHeight, + MerklePath, + Value, + TimeDelay, + BlockDelay, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "clientId" | "client_id" => Ok(GeneratedField::ClientId), + "proof" => Ok(GeneratedField::Proof), + "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight), + "merklePath" | "merkle_path" => Ok(GeneratedField::MerklePath), + "value" => Ok(GeneratedField::Value), + "timeDelay" | "time_delay" => Ok(GeneratedField::TimeDelay), + "blockDelay" | "block_delay" => Ok(GeneratedField::BlockDelay), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryVerifyMembershipRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.client.v1.QueryVerifyMembershipRequest") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut client_id__ = None; + let mut proof__ = None; + let mut proof_height__ = None; + let mut merkle_path__ = None; + let mut value__ = None; + let mut time_delay__ = None; + let mut block_delay__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ClientId => { + if client_id__.is_some() { + return Err(serde::de::Error::duplicate_field("clientId")); + } + client_id__ = Some(map_.next_value()?); + } + GeneratedField::Proof => { + if proof__.is_some() { + return Err(serde::de::Error::duplicate_field("proof")); + } + proof__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::ProofHeight => { + if proof_height__.is_some() { + return Err(serde::de::Error::duplicate_field("proofHeight")); + } + proof_height__ = map_.next_value()?; + } + GeneratedField::MerklePath => { + if merkle_path__.is_some() { + return Err(serde::de::Error::duplicate_field("merklePath")); + } + merkle_path__ = map_.next_value()?; + } + GeneratedField::Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("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) + ; + } + } + } + Ok(QueryVerifyMembershipRequest { + client_id: client_id__.unwrap_or_default(), + proof: proof__.unwrap_or_default(), + proof_height: proof_height__, + merkle_path: merkle_path__, + value: value__.unwrap_or_default(), + time_delay: time_delay__.unwrap_or_default(), + block_delay: block_delay__.unwrap_or_default(), + }) + } + } + 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.QueryVerifyMembershipResponse", FIELDS, GeneratedVisitor) + } +} impl serde::Serialize for UpgradeProposal { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result diff --git a/src/prost/ibc.core.connection.v1.rs b/src/prost/ibc.core.connection.v1.rs index 01a54671..dff9ada1 100644 --- a/src/prost/ibc.core.connection.v1.rs +++ b/src/prost/ibc.core.connection.v1.rs @@ -127,7 +127,7 @@ impl ::prost::Name for ConnectionPaths { ::prost::alloc::format!("ibc.core.connection.v1.{}", Self::NAME) } } -/// 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"), @@ -285,7 +285,7 @@ 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, @@ -338,7 +338,7 @@ pub struct MsgConnectionOpenAck { >, #[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, diff --git a/src/prost/ibc.lightclients.tendermint.v1.rs b/src/prost/ibc.lightclients.tendermint.v1.rs index ff15fefe..48686123 100644 --- a/src/prost/ibc.lightclients.tendermint.v1.rs +++ b/src/prost/ibc.lightclients.tendermint.v1.rs @@ -7,7 +7,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 a358d97cfaf1815164958c2503e296f8e42ad530..8a384ccb6dded4c17de21b8cac08ffb8eff79a44 100644 GIT binary patch delta 29316 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 delta 25236 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 Date: Tue, 20 Aug 2024 17:06:30 +0200 Subject: [PATCH 2/3] Update ibc-go version to v9.0.0-beta.1 --- src/IBC_GO_COMMIT | 2 +- src/prost/ibc.applications.fee.v1.rs | 5 +- ...pplications.interchain_accounts.host.v1.rs | 22 +- src/prost/ibc.applications.transfer.v1.rs | 369 ++----- .../ibc.applications.transfer.v1.serde.rs | 678 +++++-------- src/prost/ibc.applications.transfer.v2.rs | 584 ++++++++++- .../ibc.applications.transfer.v2.serde.rs | 905 +++++++++++++++++- src/prost/ibc.core.channel.v1.rs | 2 +- src/prost/ibc.core.client.v1.rs | 98 +- src/prost/ibc.core.client.v1.serde.rs | 348 +------ src/prost/ibc.core.commitment.v1.rs | 19 - src/prost/ibc.core.commitment.v1.serde.rs | 92 -- src/prost/ibc.core.commitment.v2.rs | 20 + src/prost/ibc.core.commitment.v2.serde.rs | 95 ++ src/prost/ibc.core.connection.v1.rs | 26 +- src/prost/proto_descriptor.bin | Bin 767889 -> 772909 bytes 16 files changed, 2000 insertions(+), 1265 deletions(-) create mode 100644 src/prost/ibc.core.commitment.v2.rs create mode 100644 src/prost/ibc.core.commitment.v2.serde.rs diff --git a/src/IBC_GO_COMMIT b/src/IBC_GO_COMMIT index fa8ec6f6..5fbbaa66 100644 --- a/src/IBC_GO_COMMIT +++ b/src/IBC_GO_COMMIT @@ -1 +1 @@ -dcf6e340e31c40c828a6340836b3800640d30570 \ No newline at end of file +66ebf864d7bfe2193a96c972a9e74196b2ddf104 \ No newline at end of file diff --git a/src/prost/ibc.applications.fee.v1.rs b/src/prost/ibc.applications.fee.v1.rs index 82b62a46..5cdaf9cb 100644 --- a/src/prost/ibc.applications.fee.v1.rs +++ b/src/prost/ibc.applications.fee.v1.rs @@ -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 ef34e6c1..e5065d7e 100644 --- a/src/prost/ibc.applications.interchain_accounts.host.v1.rs +++ b/src/prost/ibc.applications.interchain_accounts.host.v1.rs @@ -39,9 +39,10 @@ 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 { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.host.v1.{}", Self::NAME - ) + "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 @@ -96,9 +97,10 @@ 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 { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.host.v1.{}", Self::NAME - ) + "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 @@ -116,9 +118,10 @@ 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 { - ::prost::alloc::format!( - "ibc.applications.interchain_accounts.host.v1.{}", Self::NAME - ) + "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. @@ -444,7 +447,6 @@ pub mod msg_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let inner = inner.0; let method = ModuleQuerySafeSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) diff --git a/src/prost/ibc.applications.transfer.v1.rs b/src/prost/ibc.applications.transfer.v1.rs index 1331a219..faaad4dd 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, @@ -89,6 +110,9 @@ pub struct MsgTransfer { 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"; @@ -521,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. @@ -836,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, @@ -1018,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, @@ -1144,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); @@ -1470,6 +1272,9 @@ pub struct Allocation { /// 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"; @@ -1481,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 e34731ee..f30ecc99 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)?; + } + 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(), + }) + } } - let mut struct_ser = serializer.serialize_struct("ibc.applications.transfer.v1.GenesisState", len)?; + 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 { @@ -451,6 +633,9 @@ impl serde::Serialize for MsgTransfer { 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)?; @@ -480,6 +665,9 @@ impl serde::Serialize for MsgTransfer { 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() } } @@ -503,6 +691,7 @@ impl<'de> serde::Deserialize<'de> for MsgTransfer { "timeoutTimestamp", "memo", "tokens", + "forwarding", ]; #[allow(clippy::enum_variant_names)] @@ -516,6 +705,7 @@ impl<'de> serde::Deserialize<'de> for MsgTransfer { TimeoutTimestamp, Memo, Tokens, + Forwarding, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -546,6 +736,7 @@ impl<'de> serde::Deserialize<'de> for MsgTransfer { "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)), } } @@ -574,6 +765,7 @@ impl<'de> serde::Deserialize<'de> for MsgTransfer { 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 => { @@ -632,6 +824,12 @@ impl<'de> serde::Deserialize<'de> for MsgTransfer { } 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 { @@ -644,6 +842,7 @@ impl<'de> serde::Deserialize<'de> for MsgTransfer { timeout_timestamp: timeout_timestamp__.unwrap_or_default(), memo: memo__.unwrap_or_default(), tokens: tokens__.unwrap_or_default(), + forwarding: forwarding__, }) } } @@ -1215,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 626a397c..48d2d1a8 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: /// @@ -49,32 +91,546 @@ pub struct FungibleTokenPacketDataV2 { /// 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 { - ::prost::alloc::format!("ibc.applications.transfer.v2.{}", Self::NAME) + "ibc.applications.transfer.v2.FungibleTokenPacketDataV2".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.applications.transfer.v2.FungibleTokenPacketDataV2".into() } } -/// Token defines a struct which represents a token to be transferred. +/// 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 Token { - /// the base token denomination to be transferred +pub struct ForwardingPacketData { + /// optional memo consumed by final destination chain #[prost(string, tag = "1")] - pub denom: ::prost::alloc::string::String, - /// the token amount to be transferred - #[prost(string, tag = "2")] - pub amount: ::prost::alloc::string::String, - /// the trace of the token - #[prost(string, repeated, tag = "3")] - pub trace: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + 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 Token { - const NAME: &'static str = "Token"; +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 { - ::prost::alloc::format!("ibc.applications.transfer.v2.{}", Self::NAME) + "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 c1e34b82..24cfb6fa 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 @@ -177,6 +503,9 @@ impl serde::Serialize for FungibleTokenPacketDataV2 { 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)?; @@ -190,6 +519,9 @@ impl serde::Serialize for FungibleTokenPacketDataV2 { 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() } } @@ -204,6 +536,7 @@ impl<'de> serde::Deserialize<'de> for FungibleTokenPacketDataV2 { "sender", "receiver", "memo", + "forwarding", ]; #[allow(clippy::enum_variant_names)] @@ -212,6 +545,7 @@ impl<'de> serde::Deserialize<'de> for FungibleTokenPacketDataV2 { Sender, Receiver, Memo, + Forwarding, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -237,6 +571,7 @@ impl<'de> serde::Deserialize<'de> for FungibleTokenPacketDataV2 { "sender" => Ok(GeneratedField::Sender), "receiver" => Ok(GeneratedField::Receiver), "memo" => Ok(GeneratedField::Memo), + "forwarding" => Ok(GeneratedField::Forwarding), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -260,6 +595,7 @@ impl<'de> serde::Deserialize<'de> for FungibleTokenPacketDataV2 { 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 => { @@ -286,6 +622,12 @@ impl<'de> serde::Deserialize<'de> for FungibleTokenPacketDataV2 { } 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 { @@ -293,13 +635,14 @@ impl<'de> serde::Deserialize<'de> for FungibleTokenPacketDataV2 { 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 Token { +impl serde::Serialize for GenesisState { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -316,15 +659,552 @@ impl serde::Serialize for Token { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.applications.transfer.v2.Token", len)?; if true { - struct_ser.serialize_field("denom", &self.denom)?; + len += 1; } if true { - struct_ser.serialize_field("amount", &self.amount)?; + len += 1; } + let mut struct_ser = serializer.serialize_struct("ibc.applications.transfer.v2.GenesisState", len)?; if true { - struct_ser.serialize_field("trace", &self.trace)?; + 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() } @@ -338,14 +1218,12 @@ impl<'de> serde::Deserialize<'de> for Token { const FIELDS: &[&str] = &[ "denom", "amount", - "trace", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { Denom, Amount, - Trace, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -369,7 +1247,6 @@ impl<'de> serde::Deserialize<'de> for Token { match value { "denom" => Ok(GeneratedField::Denom), "amount" => Ok(GeneratedField::Amount), - "trace" => Ok(GeneratedField::Trace), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -391,14 +1268,13 @@ impl<'de> serde::Deserialize<'de> for Token { { let mut denom__ = None; let mut amount__ = None; - let mut trace__ = 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__ = Some(map_.next_value()?); + denom__ = map_.next_value()?; } GeneratedField::Amount => { if amount__.is_some() { @@ -406,18 +1282,11 @@ impl<'de> serde::Deserialize<'de> for Token { } amount__ = Some(map_.next_value()?); } - GeneratedField::Trace => { - if trace__.is_some() { - return Err(serde::de::Error::duplicate_field("trace")); - } - trace__ = Some(map_.next_value()?); - } } } Ok(Token { - denom: denom__.unwrap_or_default(), + denom: denom__, amount: amount__.unwrap_or_default(), - trace: trace__.unwrap_or_default(), }) } } diff --git a/src/prost/ibc.core.channel.v1.rs b/src/prost/ibc.core.channel.v1.rs index e4c94810..0748b2c1 100644 --- a/src/prost/ibc.core.channel.v1.rs +++ b/src/prost/ibc.core.channel.v1.rs @@ -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 104b926e..996d2172 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)] @@ -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"; @@ -1726,9 +1663,6 @@ pub struct QueryVerifyMembershipRequest { /// the height of the commitment root at which the proof is verified. #[prost(message, optional, tag = "3")] pub proof_height: ::core::option::Option, - /// the commitment key path. - #[prost(message, optional, tag = "4")] - pub merkle_path: ::core::option::Option, /// the value which is proven. #[prost(bytes = "vec", tag = "5")] pub value: ::prost::alloc::vec::Vec, @@ -1738,17 +1672,23 @@ pub struct QueryVerifyMembershipRequest { /// 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 { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "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, PartialEq, ::prost::Message)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] pub struct QueryVerifyMembershipResponse { /// boolean indicating success or failure of proof verification. #[prost(bool, tag = "1")] @@ -1758,7 +1698,10 @@ 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 { - ::prost::alloc::format!("ibc.core.client.v1.{}", Self::NAME) + "ibc.core.client.v1.QueryVerifyMembershipResponse".into() + } + fn type_url() -> ::prost::alloc::string::String { + "/ibc.core.client.v1.QueryVerifyMembershipResponse".into() } } /// Generated client implementations. @@ -2729,7 +2672,6 @@ pub mod query_server { let max_encoding_message_size = self.max_encoding_message_size; let inner = self.inner.clone(); let fut = async move { - let inner = inner.0; let method = VerifyMembershipSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) diff --git a/src/prost/ibc.core.client.v1.serde.rs b/src/prost/ibc.core.client.v1.serde.rs index ef3244b0..ed7b34ef 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(), }) } } @@ -4362,9 +4239,6 @@ impl serde::Serialize for QueryVerifyMembershipRequest { if let Some(v) = self.proof_height.as_ref() { struct_ser.serialize_field("proofHeight", v)?; } - if let Some(v) = self.merkle_path.as_ref() { - struct_ser.serialize_field("merklePath", v)?; - } if true { #[allow(clippy::needless_borrow)] struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?; @@ -4377,6 +4251,9 @@ impl serde::Serialize for QueryVerifyMembershipRequest { #[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() } } @@ -4392,13 +4269,13 @@ impl<'de> serde::Deserialize<'de> for QueryVerifyMembershipRequest { "proof", "proof_height", "proofHeight", - "merkle_path", - "merklePath", "value", "time_delay", "timeDelay", "block_delay", "blockDelay", + "merkle_path", + "merklePath", ]; #[allow(clippy::enum_variant_names)] @@ -4406,10 +4283,10 @@ impl<'de> serde::Deserialize<'de> for QueryVerifyMembershipRequest { ClientId, Proof, ProofHeight, - MerklePath, Value, TimeDelay, BlockDelay, + MerklePath, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -4434,10 +4311,10 @@ impl<'de> serde::Deserialize<'de> for QueryVerifyMembershipRequest { "clientId" | "client_id" => Ok(GeneratedField::ClientId), "proof" => Ok(GeneratedField::Proof), "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight), - "merklePath" | "merkle_path" => Ok(GeneratedField::MerklePath), "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)), } } @@ -4460,10 +4337,10 @@ impl<'de> serde::Deserialize<'de> for QueryVerifyMembershipRequest { let mut client_id__ = None; let mut proof__ = None; let mut proof_height__ = None; - let mut merkle_path__ = 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::ClientId => { @@ -4486,12 +4363,6 @@ impl<'de> serde::Deserialize<'de> for QueryVerifyMembershipRequest { } proof_height__ = map_.next_value()?; } - GeneratedField::MerklePath => { - if merkle_path__.is_some() { - return Err(serde::de::Error::duplicate_field("merklePath")); - } - merkle_path__ = map_.next_value()?; - } GeneratedField::Value => { if value__.is_some() { return Err(serde::de::Error::duplicate_field("value")); @@ -4516,16 +4387,22 @@ impl<'de> serde::Deserialize<'de> for QueryVerifyMembershipRequest { 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(QueryVerifyMembershipRequest { client_id: client_id__.unwrap_or_default(), proof: proof__.unwrap_or_default(), proof_height: proof_height__, - merkle_path: merkle_path__, value: value__.unwrap_or_default(), time_delay: time_delay__.unwrap_or_default(), block_delay: block_delay__.unwrap_or_default(), + merkle_path: merkle_path__, }) } } @@ -4623,146 +4500,3 @@ impl<'de> serde::Deserialize<'de> for QueryVerifyMembershipResponse { deserializer.deserialize_struct("ibc.core.client.v1.QueryVerifyMembershipResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for UpgradeProposal { - #[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.UpgradeProposal", len)?; - if true { - struct_ser.serialize_field("title", &self.title)?; - } - if true { - struct_ser.serialize_field("description", &self.description)?; - } - if let Some(v) = self.plan.as_ref() { - struct_ser.serialize_field("plan", v)?; - } - if let Some(v) = self.upgraded_client_state.as_ref() { - struct_ser.serialize_field("upgradedClientState", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for UpgradeProposal { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "title", - "description", - "plan", - "upgraded_client_state", - "upgradedClientState", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Title, - Description, - Plan, - UpgradedClientState, - } - 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), - "plan" => Ok(GeneratedField::Plan), - "upgradedClientState" | "upgraded_client_state" => Ok(GeneratedField::UpgradedClientState), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = UpgradeProposal; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.client.v1.UpgradeProposal") - } - - 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; - 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::Plan => { - if plan__.is_some() { - return Err(serde::de::Error::duplicate_field("plan")); - } - plan__ = map_.next_value()?; - } - GeneratedField::UpgradedClientState => { - if upgraded_client_state__.is_some() { - return Err(serde::de::Error::duplicate_field("upgradedClientState")); - } - upgraded_client_state__ = map_.next_value()?; - } - } - } - Ok(UpgradeProposal { - title: title__.unwrap_or_default(), - description: description__.unwrap_or_default(), - plan: plan__, - upgraded_client_state: upgraded_client_state__, - }) - } - } - deserializer.deserialize_struct("ibc.core.client.v1.UpgradeProposal", FIELDS, GeneratedVisitor) - } -} diff --git a/src/prost/ibc.core.commitment.v1.rs b/src/prost/ibc.core.commitment.v1.rs index 77d2ca9a..ad8941a0 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 9173f7e8..4c870adf 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 00000000..8a94d023 --- /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 00000000..ba3be007 --- /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 e11cee61..042443e1 100644 --- a/src/prost/ibc.core.connection.v1.rs +++ b/src/prost/ibc.core.connection.v1.rs @@ -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, @@ -320,17 +322,22 @@ pub struct MsgConnectionOpenTry { /// 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,6 +376,8 @@ 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, @@ -379,17 +388,22 @@ pub struct MsgConnectionOpenAck { /// 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/proto_descriptor.bin b/src/prost/proto_descriptor.bin index 8a384ccb6dded4c17de21b8cac08ffb8eff79a44..af9418f60b8e1af86e783d66ec87d933516dae0a 100644 GIT binary patch delta 43131 zcmcG%33yaR);Hc&ck8|#vUCRXy zI(6#Qa@UydZ%ewb&KleER5Df>#OF^X^7S@t(qTgXg0f@ zVSIC|U1f0|zQ9gf5Uprzs*lcTXsWBLt#8cDiLlPW@^0~M;hgw~-Teh)WcqZOJS|n_ zS8)8B^Dd4b?Qu!h@SWUFJvVP?tR0G0Ry9`D*37A@X{@iUY?>df%w_T6;lh#(l`=k& zket0TT2~*PU(tx{oU+eyvyVz7gu2_AZZ@jn%8L4$s+xtl8u$-P3ne98C{sei?KGF2 z`sk9{r68^o@w8Nho+h!)<9hx>V{gaH``rDX1f>6;3#hP9u(@~Nke>d4ZQHJpqK%<- z@tFfgvZ3)!1Nyh##Wep{*0fd&s-o4EQ|qG*(VF?uP<8yX0sUB)c>ch4A(g`)t!Y{^ zV|iUPv>`rm;0#t8-!`yQp-RlIkJh2XqLpKa%;=i=wUrP`XhrHyT&O%4k z*MrM>)zLXh`5Mr1D+`J{XC|d7u{MN8*r^MumPISQ%m!r+L$biS*)T*{I>-Ncy4L*E zuv<8PfX7FVED1~;J$CrWi_&kf;`2ui$;hx%MvodlWBioKbIN;^_fG#ue9OqS*`Z83 z=%ObLpOyYE{Ab0xk6IZ#{ETK>A)}-3_jdDBqizYXOXH&^uZnGCwr==13uz;G>+ot8 z86K&tu9zQPR9jsct&b@Ei!7+Ek2KUp=T|LQj$VsYMi*2xRX0ZFMHf{pt*WhWh?LBW zB2Tm=QV~(2up?JiG(;9u)i*Royg^nLiOg73)eynI=z;~&QS%$CmPV_WM=EL}#Z@&6 zs%oklqmjCbhQ{JD+fK0!;!QA@?m`@_X6D$}altsCareGGnN6T3jN@)DPI%-BicDHa z8_!!S0va-oPh`}PaXd0UD&?Suw8`<}sXNB&$TgX#sxmrqP0q+x0!Hv&C$umTp!Fu*|hGdbNy}Y{{r2s4iXA|UJ=BYvkihEsfv)$0D_=i6>Y+Hi71SudGQaXb?Y}TQJA6d zyhLGA=XoK~b12MEcwSz<-CGm}Yti_K>3#b}6NNbnM-zof%cG$@#Ro^>Xko-YUlazg zF#g!|>HQWa3Tr65FenBE>LSfwm?1QXAj;pNlYNya48>m@A2{Rcev1=@brfElC`#X!k{?9s5=8tUQWq?A(?Fyy;u7(LNF5QGA{vC@SI^t2oB>d&Pf!Vf zN`25(92%PSt=;AYK&8H@*!~^^4r0O3To!MfdAk3yL}?qPmjzwTq2anLT%zi+QF>Wv znY~?>#&BH`zxToi`maco4x*PFA$=u_UpK46*j7T_ zQ*=UrkOEBtgCQ4W1ZIX^P$MwE(C&iq#Y5(e%(p%Mk6Dpe(AIRQuYM!*lPT79j)A7% z#CTg#5)i5ZD60Wz5D12;R)8pa6T_fWAgZ~EVbn=VNQBE-q7oS>0dy%bFnmjlq4#82 zj6ftuI=CQ6-NHIkZxT~Hq_1Mo0-2YC6hN00v=v~2618U)gCeNRptOoX6C@=-s~PVq z6JuNhDZnl%4Ww2x3=vrtgA-uejxHz)ccJbjrciVZ!zht?bqTtZbWmEuFiun|D6L@_ zC<+9nHLPo_o1IFeG+)TPjqy0sWV%Lzy^YzqcAjlgGWE*sOwTV)iHxtAU)|Jz2^zLE z&9-DJ>PB*khd@8w&RT^$1PI>FGIKoyIJiB=+U6yyK#sLcZ;L8MFZ=f@sQZxYRRIGE zL{b&hgKHV4ZI>&UQ6QiWsj3m^#q~_@p2)ysAPS5}l)7>~YgO!J0nzoWU5SSP(e(_2 zO7;Pm_`RnX2Iv8F`vCS1AO@!tIt(7bu&Wrbcrm~U%|PZm8Skz#!{`y{l7iI(n9wo! z4ge!1Ze}obr^l2Pf=kR@t%2bq(4_>+2T(HA1zH5}0&uuUk+MK)18d*GeuRt$O%LW~ z#<#}*aLL0No0;8Obr(&D`rYvhFD)2#w!Y z-o{cf`&=&?%>yC*zIf$jH(q$3M@>iTYd&D80T#E1T5!yR<^#-km@!Nt znofiG0p`!QX(rG}ZV$zW%{l+lhg{mgfxU;^!3q#19%6;P1bYBM`ytl1zZk0;jn#)4 ze@2Z}z{veDv$O5rK+OSC4Ljn;=S&*4!xgB&g8v<^Km`KjcCgGgLbU|~_3U8qJFZfM zkm2!oZ0^;gA5SJkJ@Ytgm6<3_^^t5NB=pQ65JU5 z&&iZX7yit$q?I6+;LHF4WqH-51jJME&huU${Zuj~_%!-ctW`#W1rqvGEEM(-RFLHt z*tfcrpdo*a51zkfu5Sj2~hH-xc53*pMVw<}7Aj_BL6schQ zAX!r>I}Oq~#LNLM2%C6_Wwceo(nwf`Sbl%|Vj7|7^LOKaU3f{^yR4P85t>0A2vE8j z0Kw(EEIZfkg#oUI%nz9F`S|!nlGOu!)VA+v(^bjSiAjm%Ht z4==i4#wV`G1Qw(}aYaT56#LW_nSdoiicBC-;!_gYm5MOnFXBau$HzBU^_cMm)4i9gvWadO8me=o=97T^s~vT(+VYk@Z{49CC;*Rr4N@wq^TkON2a$oW3AWNg`cKIv(og~juS6P3{6r->srIIa^q=EXYPuBvoXkCu@;! z*rGO-(o+?9WJH3iK*$Kf*Yj+*al#$B0VS0<0HXvDUJ0^SH&BWFG?NffAa3FDn`&Q) z-IAP9;*pVDMV$u!YOWSGfH0~6O4|kyqh~c&3mbr_bTwBC8-N(JtGRM@#DZxJ=h6-W z0wsV%DQ2J^nxEHjtkKC30tBfwJfpP>g47xwZmXCA>%a4uq9p}DmnoVje&_I$IZ?cE#O;*Lft!X0PMHG*vs<>~%an%LP$p9dDg$w;*r_ z5~zMdb7_5lHfV!Kf@b6mo@i)3-oQh0frug?v4Iy9+A9PFAi6z=zANp|agp5gW(dENJOL~YJW3NTua#Os&-6nn&@;0J|AJRZo7 zJ>tm$@dkhe6pJBA!i4SQyuE580uBVa{fdYKz@V!V?K#D0ioppC3%1#|B@?1fFS>pJInxr{7ddIGf3TEc4Y_%lmNPv z$W?pUm0<@Yi`+_x072?y5@IKCYKF|$xbGkFN3Q7@dyONcNSvC)>FX}1fIuIhqz@3B zzV31g5aeHXIRyyvue+R@#Oa${g(m=k54P0olH< zT)Sfm+xHbISx+dL6*7-<-#77D*Y$`U<$h@hEE4T8SIGdO5`eNl0fPK7mpnj_KjtbK zK=60WRWgf2c-)BX&#Ko zfrey}yGTYE0D{zMjv#|%3NkpuRglInWB|}5MKUQm8q3w!5 z$oz@>Zq-=0_#7EHHx$nPi6iVl)dfffKf5vj1kM4<>HtCpKf5vji0XcJWdIP>{Y)}& zNYewv%t|euapQ*AN-aTx6kw&M92n#gnXoBArU4*Gtkf{SNoLUY>on{!$wcaZfG#r> z6}Zl$MAcoVh4S6Zpmd#v*a9d`17(0WXk3PE0f7`imlTb^8#ER6K`KbyptX@51W=T1 z*WMm2nuVe_Yw@dY8Z-N5j{*(An>FRX1ZZ;zV7g0zoR6C|P>>CQJ_78}*9GAR+^qHJ zqv(UuDlOjj<}sJ7^5~OqvdW`RzR4<&KKUlAJo*Ocukz>{pudXfKbi_XutVk}n(x8p zJvWzG>5pjsOu1=bQ_t^;|9IQ!!MogQfkU;sTp0sIwY#*CG~@tL?Jf<5{2MalHub>n z=CZX7Z18T61aY?z3wnTP{9dhhe{3lbi^%(I{G)i+*s~saTGl`7k*D5& zR!f%w0+gU4T90zkSpY%)S*_P7vB)7%B=;U^za|?1?RZ_|L&8sMv>RSu+gMwUeeCL} z*pqCCVndR4up48wk;eL_D0xM-b+pG#zb=?DrnDb6C!_N(r;T#jAe~ULw4xh!!xvS} zUlh5rs=6BG>uay1E$`^E`O!K$WX@7*Q1V#`Hk3Nzmj%U!Bk~K1g@Mo z%n@nCVGXo|nu8{Q574fwtF99Js@=e0Wu&PN$1u>yML72nsjQt3n>&AgZ9NWe#1>XB zr|PDXgn9`HA+fqXT2YC;+-N=8F8D?{A&-W#$nmp}wG5G-OHdyHo=3jv4r46ztl0s4}=zzxGj(5BBHyH;s zE7Kl@#Uju&9N&uHa_5-hw=_KG{jBF+}bqE-qH9##VKu40CXEon-uS8YB7MksQ4W% zSDG|{X!JW;CwCB%1$xIDgk*u$$g6=CPak=ff)-C7X=-Y) z#p3BBt+2>`3*rH@AbGU;)r~WG?5IbAR!>L0o}ty#QO{D)>glLwDJ(E~)ML^jio~Q8 z1`>~H-0e2nCjjUQgVtEbR6Q{;LyN3qTDqKG0HUH}TIUiaNxz`gb&w09qGMX$fvO@b z!H#=UrzIFbw<6k2IPNuwmSD%d2GJ7ic+6{202LkgS`8|3Eu$6OX$?m!Xo^HBwCuEoonQr`VW+i7PZvbPPHSCz*fCKB zqGV^|=9X*b1X0CVuL|s115}f;&9Q9_P)*7JQN>ve=MZESK~!;8>nJB>q@s$mTF*ZA zdf5zw*nWwBvSsaX+R*;Rt0M(<{NgDsMc#hVLhjs@f;xVo{uwVAMbvGj9&g?{W<)Dc zS&1dHs=O7btkjiPWOItft<*!(@c{@bD|H;V5TOT~B5^nC%>%ckvf-(qbF)V$6?AU) z=un96W<4=qr-IJSIwJNI1F<>6bF20Et@r$POd6=H_Nb(R%4&}ah3!^*+@yiZYU1X< zrDPDZTdQN)|7iUD?UDH9_c~+JK@KRlap@qp)+3h=a%*)J6tQ_a$gS0}R)0y7Lu~I3 zotK55QsmmkufOk>;Ta$av`aDrB=7J@QW)?KJ>*)S43NA-?^uQ?>sUWji zSKA~2L1r_Nxmu9P!WN>=2ZU?lo1f?tXAcY;mIZ1+xlPLgwQaiEkhggjsBP2L9v?tZ z+oofW?`B408V%SUU-`hQ*mhlQNZ4XS0-)TG0En@=UB`w5ja4!N59s2=84YsKen3wQ za&pa*K@=1qZB+(C<{x$6SzT^b(n$KF?$5E`HqfY`a0K@>uX*rYK6{Vb5@5mI9$gJT zfGD&_PnXLaRYu1$hlU?O48J|PnkE5a`0dfp8)Sb?T^Jq~ktMdlQy)dOPz z>MsG4H4Rc1y`-ngxG11sfg&$bWnKYc3rBDy)?Y8_9_XfSHHAbWo{x225MF0SE?g9a zQ&mr%Rdf8&#XSD?&bvm-X3;_k*`#s?Il0OodmMB>NS=MB!l2dfQ72SXL|hhx7)@a+hvq}=9MA`D;Y#70lrTzcTj`{nm^t3A)9^D zuSZJC8oO zL*KcB9$7&DJ9p3n1cC2p(9>RikXGrZaVUGvgc0}+iJtc8(1DH9?r=vc=$v+kJ3!Dm zO~akGA89)KL61MZaORYt0VVpu9rJ)t44@qI03o3tXw1{lO~Jxn_iZ!f(4`6LC*7ZA zuP5Q9kehkE(frb%<1BW)q52tEaCN<*_67i=(DjCj=mP{-*Be;qla2s{^sYDB$^{cZ zsQ&dvM|or@g&f=)48G3LWNxw9d4qv1m_m54NG1+$GW4`?{Jkgh+vAtqgb^ud#!Ut` z%kR`wUhr|7(VV~AVbgCjbiZ(mDJS{6w;32yv?E3cz-tY)$tYly1VU~Z3WUf3*Y|*w z1JXA(TTlI+4c_R9fh^2MLs_sC5vE%Ujy$O6egkLcr08fpdcT4AqXHqx`;C0L)6yulN%@Zl$?I8o}fi6NmV)yEi_-~)?TKq_IHWK3_$=Luu z8sGPH*G`WnXQP%rO4&BrqTy)7K7)4+-)c99_r9o|UtMw4a>Vo-8Y&RV6^q4&NClRk z4UM#bjRISb6&nulRv}TWL&X};jv%>|R(?RzdX;`+-C0{7zw5a+{UakQs;g-MIKE*# zPI^~iy?a%(5=ZZ_V;~oWO^q;OZoOBE!@>(Hs;cAHKUWgN>X4SWSVxWl3KhueaT|kH z&@wZwC(yxkEXHZ|ESAN{i)$p2&T_Ghb#N5R+$LPfNHE}5D4U4&Ef(c;s=o`Cx3X8s zhR%k75-_xCpQlx16ZaWvuPa3u(R~K?x>RABSBy3#E=co=fuKB{Ifu@H^egeYeUHz6 z#iLKA?-h?enZ8#HwKswi=&e@__*;@bnZ8#H6^lYD=)YnhR`ivm4^ju>SHF1V;sYLi zibWmp=#%L?V5oU9MVP(=hME@vg8l(R&5Hm*|A2vcaj0M)gX3WQ>6eDjKIoCBW#B=N zJXyqpo_NS29yD6ZDJO-SAb-#ZOD_T-$R9L1l*kZd3JsulrN@m&MUOer2(Bfe`COD_WSh@eqgZa*i)LuXV!H2A0S>HD9JeP~#6cQ^%m zo*0TB8M-`HBw*A6ggo^i5Ew%r891LWEtW70A19Zf(G7%Gf(GZu$t3`PV(9W*R*D|O zY92*^k!Loj5*nzVkS>vbkU}oX=Y~4y3JAIb(A7#h`u4e@j+7!5v_3c5x@tl*;^#)E zF7^&iq@YCR*9JdrXyLnX_<>?T&DpOOvDnv!)mk+P2hy;hHuOAYrR8}wAmpAoXoyYq zqXssar4Vp92`gi-Nq{B7Z4nS?(J^X~TLSQLLvOF@h~ZcgiU3oXsFj3p+`#UKTLeux zk<1niKp;G}aIXW1B(@-_lV0CwBD@QP+c!X<#7Xo`EKv!R?3?5wG)jQ*ir}^f5D5j) zXrlNwx$UI*KzMDZQ!d{ow;js(U2;n;784j(?KF-{AjpEj=(Zgy@O^UIshffD+D@lj zzE5sD+_+PQ-Zmjl@<@S@$7iV%>1@j>ng*d{F=!bIoH4lEHUtFO0d%#Dwv^8pYSRX( zAa=%3n>GN^HD?Sgm&Jrf8-r&J{t&#hIKN@Zwj7FSY6Joqeu|%YqkZhBWJ2T${A8%pj3OK5GqTk1 zqjDhhlL7Bn4mQL+elfUQ52Rqw2+$P+PU9n0?b{#~w0<#g9$y+A3V!@zq?UFU{$~nD zd}F0aNAzO&4MHo;ggk>Fw9-^-Po#p-N>i;p0fNv<6K?1z8nn=J^9GaOX=>r#IG!zM zSDO7QaPx)&)0m;<^k$m;f(3}Z|0!M(I5FS*Gu`MfCRX+*$fAXU4{lP$#q;vbe>}?&Ot$$Zs*Rtffp;9Op2p>cUpke{}HZl4Q`AA7cmQ*0_U0<~j{uCrDE{ZlJu}|BMsM=$n zHXhd`b5A|FCYgKE;WfnlQpG*S_FCe8f#5#oawvQzS!1Lzx(q%O4tUTk;5G?A#my|q zH>sA(bXB9g+_$8n{&IAmOA$Yz2%hZ8vq8-s^RxROMtE+ zN&z*;Oc)|s9Xh7EdVtKJ840 zvc2DbBz{5!+g}NcV$c8-QaYS4{W2&GKih!eM%>Huc7$7)$ z#vC|VcpC(Y$g2Mc-n*Ln-pVXykq!b6@W$*oP@d3AKz@eT4t^fg|$N{%Y0fMCiZkGat01vob z3J_g-fVz|hRT|0uAmlf6@Ij9}4TFQO`nh>`|Z| zKI}0_wH!9p;x0|}@L?0a9{E`S!Qf%DNQPSgg2BUPx1RPm!60h;z~lqN1OESfrFsAE zEJd&z-$XaxWJRPPpp^j8%n!_<+%QfP3i5&3Nya7tii)9zWHr)AK|YoWg5Ls2&>;o+ z*i{guqOl*l3IY&xK6Vv^wsbxd3Nks3tj1@qh5$k_fKo#MLad*;8j>C|zchV6DGi~W zn=eg-{iz4jNkNVXw=`b&kvaH?+dd?KuOn_Z0z|PRZZ`r1Uq{F(eTO1%>C{E1nwvj5 z%x0hRNRaI~<@O`;P$pN=0D{CRQ|%4{L_eM~)$Slb^y4WLyMrXabg~3zqyX_70zBi@ zB92eF0z@imIpYctAZj_|3XnFjeiQ8r(G?&d6ay#)2oM$i=n60+Wd36M?zUv` zRUB70{n_?GYI+7qaFx{@{_GH&v&vH43M{HxWhu)G5ad@`%5DM#SF0@5c7SO6DoeE; zAlkmlLfcQ$7|EdM>unZaZ^fs6aeUNmmRg(xPj%mJsl~Z~Q4J7sB`6SR$L$tY!R_Hp z5ds<3TJh_??9gtlr7r3SH1e&ra$4KxseFLfS@D;?>=#>SsXGvqk2+$VC2p8d+p!pl zTm1Ky90h>UH9*KQ0uVYBx70!rAS#brc{0Wf5JHGs>QD|q2;ujZDYtR~LI}UNGTNsI zMa`g!9gEgaBk>#6I9@fR0gk2CPe?^Ij-}R508x!&sW5&9L7Ob${@^$0Z1U)k&EI4x z_XnwEfK!8vTpwuLQV0^QM34FDN89Wp+@3(ya z)m(7oR+f3ch2z05(^MCtW%45yf3*3juP3nBBbF`iYyeMvyu;GvEmZ-7X&|IGDG=ag zhoyXKfdB_PEOkduAi(+#3+L!)%}oeo*lFqQ#DYh_pb3Pc8KWE^x|3Q#>nM>$l)*N1 z0s*2sEm(5$P(#G#V-}Yu_W*$)K&c1-A=$^QV5Tso072_93s?WhvH}F9$1DWU#pQyK zuz`PyTgUH?{mCOi4E@PcG5C*~ImrxU{)DB%7a^f809|HidU?X5 zM8bH&3dtZDGK10+mUO&vWthM}Tk7~KAhZjhONzGA{%ol&7NmmIpREjeZ~&kvi{q=3 zDHLt7)M;xpQi3ieiubm7OwlyZV#U<1KXQXqizjSke$v8W4Jki5I_6+T6JxRJCnL@|xw$#bgkl5D(=u+xUVcgvwR}{_KZG~i96}drbw}qprhe@?F zL*{dq?|Fao%#-i1*mDTFiU?39nXl(9{<0-Ej{t+p^Ohy=F##midBIY_J^>>G5HbQL z5a`brEENGG1TyTi)Ey)NON7*4Lc}P>xX(&U7b;H}z%M2jAsRqRvKH zRJY&4x;G7D0w9h%@3*=gg4Afx5(0-RUa?f5jNnYj?bU?b2my+(S$ct;ZpUPioRIm3 zr5~^iF>0w$77D#(>7zXa3jO^Y1X^{_(nqS^gNc8~;_oMVkBs;`mX)RiE8<4)dYvVs zDeuNC6(!B2EiF)d*HTeZLV(0!OYLk4SR&+Bpg^F+VM}cV5(4mhmbwckV3Ytth8hGy zQKumPT$Fei1FPI;F@u{VMp6ClE`r-?cv?}DMb0S|_`fw$B zY)l-n`0<43Np43hi*BHTq}-tR+R{7A@&qFT5U}epVuLUc%hwi6kXr;fj(UQ`TqzN* zAb~)Mqm~e)tOW2eZ{Wxc3LxBpBR43H$)QHW09>E2V*H1M=xMe-;fbDR>l2nbIgjjM z;DlAwPl=xF?Fnn(ASHTu_nCEE@YiT2{7_qu3Vt$RO6k?2G*DiC*rD0O5*W?u-2Fi5}Y^2qAmpL~e@!;f@m^L=F{A$;1`xkp3^KA~hy7 zgf4UgfzA{fhIG=9a}l5*5OUn0-7EckwV!MljRc|yggb1=Lt5!qktU>q+DgBQGyz24 zt@Pt|QJS=WIA#rMWvd}YX~V=#?Cbmq8-|1HVDNgsYx{8$n>z0Xzp!C6Y&7b-oBaAM ze%FL)qVHDuF-qjH0Rm-i^(QPAE^PlU=I84Yokx@D@BC_GFB6yCQ0Z+6E(k^jAmo06 z$N;I_=EoXS_MNzedAmO`7s!j2K)7=O5GZlGU(5wGY+@LD@Tjppr$i4Jl>j04^QjV< zL)>1baRav3`}rRdq9+Fd2v_v9PF(L-TYJb2YU}-N<(?@(hl+iI$B7e^+2q$JLM~t#K8v~8&$lH6 zO|HgfzlHnQQvYzv4iATTf|Zx>fRGCm5D=r}Zok^5BLqln@v9YwfF(kno)!oQc8edU zr)A$5B*v}&#K;4T5;0)p?iLl1S+Kh$l^kr}YEv$NkxDaJgL+)t~kAaB)s#46ZrgjlXC; z?uKGBp&|b2k1737^jVJ*%`^aAN;F`eB}xMnrRV%Sv$&KlOgKGP7+I6&H7%IeR8?Ks zUF`b+DvdVCgUy+=?fRS_cLIfx5;~I%x~Y$FxTRU}qx`-vnp1x2$};!+{bBntT5)C3 zit7zOf3JDM&)r$<4L`OHNuhuzrG3-wE&)S7fRHnuKtMy@^s5~tfk4~d^s5a?fq<60 zNd{!HqKOQD_v<~wLvU|PJe}AeE@8+QOdDd@kf@MP-eJQ*ZDdtOaVtdaovDo%wYNew zkV6BC9#iDf{N3M54lR*G)S25&XpBIBslWTX_pqlbrXZ-d{d(8%u-Jd(D#27IvB~kj z#THHWpy{zi)BW4YY|-$1+n?Jp!4{_c7%;d$MBNESq08@*pg%V`LQ31-J2vywB_?V2C-X)eC|;ov48GSplUz&Cn%7Y z^*K>^mtlxxhs(lRub|@zD83I#AZ2 zZcE_|m$=f?=p47%QwHuPMJrl%1lhy93T3302^v_a?h2?|!UBP6b_Fu!Xb=dnwJU&$ zhIB$85O3NQ$m@#Ll3yVp$X$W_68lYh9E9?K$nHSP-c&Z7E!v%2A4MZ}C)Y<^v^%*z z>ZIMt^-+9lcXEABLNlSA;yTaBY`ZrUnmf$ z?nnS(3sPW00RB3lmn51?o*WRK$S8L4buvxz=DrSO(adJ)HG+m9g41~}QP4OV(907< z$wvXgBT8Y6qsc_cPdOUMBA-x-ojjGJfgU~S&^FgG&wUrbi?q(#*6e87cL9GJdl^(O zhm_*9vpSbub=hfG@qmQloerp(86aq%4&=z40Dz!;I)DqBG|T6Z;{7wg-MccpyXM%Zv_H1opt+GAkepG-M*Cwbmdv< z+bOCt(D>Pz9cJf`{yDiaQly_^5~O5pt7F>IQm3~5eNawD{beSFk3ce zrLANy@F2C)R%1XQKx(C}ZpsS;NUgLHXglnR0EnAx=h3$8y>T}s(<0@#DVY{2$4$1n z5>K?q*}ut#PqkRGMPZ&>ZGD~X9LQsfvTn5l8TJ^AEaXM(1fpJJJ5%!6*iLI~)3!70 zfSZEmtg&I;2PHD2s@rU5Pd*#m={DO8BxNS2;Wit-U%y0VVAk4BQ32~;yVf>?NtuOz zZR21)X)m!1WnFKpsHcD>LTax-K)=@8t>pPGfdDJ(ZG@6Zdj$fmUT-7lxpBVj>@Bpi zTRtdYH}rg*jcu*{sg3RQ{HqpmYVKm$PIfmv+llVm_>U(BaEBIWQ|Q_*{K~}*bh^4?A&&OIPZ!Vb(?jf$v9%Gr z!j9*Z>(6mIah59SQZ7zSS2rOOo&Tw&r?HmQH7*wn*PU{ZDCv4iB5)u&fWkFeUq043^#B|Ao4%^cM9@a- z8=$il^a3AsSzj1O1wrV2^T!CGBh7z|)TwX5XuJt0U-Z-Zf#4+%vR)JWB?ywT_e&5Y zh3c0ei1}aZmmtU_!G0h(3Y`c`G{`rch5I?{wis=lLl3f!X@mT!_O-NDp@4-ptR)4H zNV3vlN`ZjHd%nZ4Awv9$7=|_sp?L+N>S66Wv~=Ias;rjIRje+D?P%G!o88X?ztqz^ z@TtCUTgLr`J!@p#JY5V%vl-9U;B}2N(^?9jVQWmQG%{|+jHv_e+|SxzOhif}3#UyT zIiTg^eazI768i=cX-@zBtUSk#OmCVuN!}dj+|V>noY^1HvT{G`tGnf#*I#F4Uco!x zU~OCS-e8OP|0=^j4zP!lYffg%dGQcyF9-^zonwbsJCD8-dYg4@6)Emn-m7$$0f>p^NuHH$zb?x7F`Mq;{D5=cQTAHe9_~-GFA=n0G@o{^ zJH{?6eHza|sKVqkJk8Z|A4&pRPjhV2(xZ+dcK$b~)p0hW^lx4fav=Za6(M)=Z&YNK zC<5qt=j!9^;?n26BIE)*?>^TgPpCc5VSY!5BGBL$9qj}gRr;b=glzna?pq^F*s2$) zk;6q1_!#@0#uIF0*?zAG#gO*9kIUfUaImtU9^B1`cy92{+0@aOpm6 z+4e1K%gR3W3ej2XPkBIIA7bJ>(WkskTl*>5)mXZI|)81|10cTSwZL~EX6?bD8Oc*f9C{}y-% zYx`)Q2W+RuINsSgJe=R>JUD_cfb)QY>q^WknocYyNScT>W;8dkh`m~_Hj}+)o z*E{dwt#brERpM)F@IjP@riRdXr^`LOkA@=7{Cju_8|wV)KAs1e{m4vM!?R`}gv?f8)k-iTsKi=ZgFOXLdH-r`UPxK9`+h z*<^4M)s+;3zw1U5g3oscD|WVRW0?-Rvun$@5AjIQzwj()Pe-k%v*9s5 zd{96>gAZQ>T{9R<6WMJv!wqhK9`qXTh{I2zL|jVhAvzylHW_Q70Z0VVVSQ&P&q|Y?)v)uXE3#10;R%Js(iV{PL~*15WQQlnVo|FN z2dh%gk#R(#7=p`y-1Z{2tc?hU-1=ecv=Mo(qQll{BN9}Qb7Z1T^dW?icu!Ia8s<(L znW!ArP8*q!6E0I}BNI(BWs^ptNqD;f;((JhhPQU=ck#>0#&Am!gelaF@qFS=ey#>acZF57UKlBHpTA}zyWS;3Z80^ z!c75FQ##Y7XJRUan3{rzk}ihn#n0)^$A99NWKQ?Dw|`IZ70k*P`f6DCX6EdD80(m= z5A&c?_XMxgF7)R)JHONW z5X%50M~K)W(=NriGg*u*#ifa2Fb0>YV!hD{^vGpApmLHCxD3m9S&odrWhh7LLeGwB zbNTRddlXodpR0_Bc*S0us|E)kD$-TC-T;A}1!}wz1mX+Sc++Y4FXBDU z9dE#bI9zYl9x?`t)ObT0$}d9LRCWhW^=OOo=y?XbhRZD?z9_#;agMabeDtq-hd!LL zI3Y>06pPh((}fjZjM%s&PL^VE&ryoFuoR2SN2=a|rMO&;H#}PkhA&TO8X1Vo)p!$6 znrfH3;|+K8L)wyGk2hdJU`e9IWCWI|@rE=sYKal54er&`EgqyfbeEq{jqFDA4NMjK1gNC%LlzhcgqJZQW6fcQtSHW2& z`HF``wW|=Zn@Pp!AyMsWXZ%xqR_tme3GrU2c6FYNh=}JxwX3_zPwbcor)k%y@c{t6 zdQGBMqIHcLA4r3Yu0b(bD^1+jsNsP$IXtex@Q~ai@1Pax^FMed6Eah5f8qU{wL>*Mmt6bnnZL7rDe_{6_9o_A&scbh zGwgk>zhmv;g}=FpzCuIKsrW(bX8KAC?F0Cg!qnOYo>dK)@inH5Dzys^bpkD-Mrx9y@Dva8AzB+B=bQO=owsy!_w1dp5bv z2lx+}+Ao@L=yO=P^U`qM8Glxc;DxCv)2z#*%coW}E*dfX;-SuPW`w1qU(~Am(((z< zV>^VL{h*8#!aKBcXW9Wgk%dW6_sz8TlEOn00c4pvn(rBmSi6R)S#+@o8rocbr>>W}c?)-hU| zbM5(><=osKfyuv)(ae_CGqkRWyz^pO*P$)*rn2XATQ4Pefo zSG5_PXoTXpvUVP{f(#>*Ba}eWaV+jbT7NiQw?1XI4NE6WEcmtlaI$JZ4Qr+$zVXhc zSGAfkL!g#KkWBSZWe>P(4+!BV4p+5tSsQ_!P@7n0jdCWxrgbS9rA88PknE^)f|H|A zcR!IINn@OCuW181jY)Xo6v!HrBPVa^=8wT7oG!3W3{M&i!v_9ZO~ehCYK^cLDzceHFRyxod>irC36zl$?2Hmm$q2EeXh*`dFlf=5O6u1 zj7N+%z3`iWM5D>Is8IcYG*nW7ewYTSBU{whE<85k6h4Dk_>rDkhV%IWtz%jgQ_wCo zXD#+Eb;56HyXGuLu$x4W*BCI>c9PbboB;ydglg4ci3y7kZX$iujfR7oun43M6BE`I zvcq0`JZP3&p?H_m)fKA4wxD``+2AZM!v)nRhBYCwmPgv4ys zBqUUZ-)MSMq8945CM6*`Sv5gIG*h6dS2^7eYI9Prg52i-;}03v_*OZ00XOy1)?+(Z)Cg}EAeeRSWoB2Lt1$W5bmTyGsulBAkVPM7l?19@AAlbiaRx!_4?38 zGCqvvmVqb$CMGIqEkFo^BEpzd)-b6r885i{^48m0$DB0`3UebV4Bnx=o%uFnYP~Yz zJpMN=+v)I*wm5b>eE~^4Rff5BEqyYJ<}KTuTLp#=R*3g%F$sbo;D|a zD}(M_1QgzEx|jJLbq2k!&HBx~uDg)}k=*CH8!4_x1coF=$@jbNMv8Pd1WerFT_!vM zB)IE~-{1~g06It3?4KySjDoN^<>9 z+7o&n+?9taValC6I0iO8pt*t-|@(Y@*LjM=J*;-(DA671&N9Czbm_Ct;gQYZYg}C7q<>(!H(jAW@UKt9SA7KIcsSRX8nIjAlJ{(zb-{U0neTT7s znNyaj=Q_X7(Wj)HB<-h7Ph2*@ODE2^Ir`+nZxNCg5&;rbe#z%vE zp3H68I!xbP2w-JLJ-4NPuKuSBU0~>w`i_j2vHSJhAUxW+hxE);B;jw{mfJtqOW@{8 z;O}Skn@ktDk{Mt6*}q!m*v6@*)!R6a9?}CXKNlE{!PEt49z;0L z7iHm#Vc1$5t({ML!nz%=3xu4yTvK=6>tuvl-YPMc@N}`jNFFmhu6+{qh;LjTP0-Lv4)IUkmK@o<>F% z?FFr(xsa~XirIZNBXRY~)94$+FDWU!bLD8Of4*q}-U6ekVf+ zgd`$n_YG1amr_M?g2(466K~H$A{$(ZAQhdl!Ig-d;5WDuAy9C&fh1B19`Ks!UCg%? zJj`^ql^eNEOD|(==q|E9q)B*wG-Te*_!iQnvKW3z(Etz8-0g}6AegwDwRa!=Bqr`= zy?P7LAQht7;);eq!Ne9~d* zaJwD5?Fb%p!W1#Uu*?7EGJq736p+3uKxpIN7_QDO0t2{*{sQyuN5d|5zUc=8I&*+A zKJ5kO?__raC%8CHd+<947-g5f=&C!AQ1=&EP%1P)RPZ9}LmO!Z6+s0rvWb&i5bFLS zn_Mld5K^VOzsROsF1Gn`EgMfyIP0d`L!6Tpwpso%Q&(e=LP-p>k0eZ-zsxZGkdENm z^J~oa7U>9a-r9M7pfN7}HBym|;5iGw}hhG;wvn)h(o=^a0W>>QLNRJ;Z$PQiry6z8GXoNIOKmN-swU z@8un5=wM?);XCJgFYh4KBie{Op!SaQ;9%n^*V~8FtVLt!;P7Jiz{p!_a*Sy6TYFa5Z`?>n`-E-E^!FZKTSa)#1R(N)-~X8pVm28 zUgTVHkx`H{uC{K3zVCxV-!zd}Jkr*Ha#*F-4}t59zUuZKIBkQQxmPmZ@lSQRo?)Q9XCzr=)C%p1g#P1 zO{eYop7rH2h@nX`lPKrHjmyqP1FN2bS@2x z4yd4(i(u#g2t~vK!}uUwsrvi{uFFWGR4vMjV|IbjR{~Swa$mh#5OC#X zJ88#xP7I!A9*!8v%BW3wY3|WWj4CY;-LBH0W_h`NMGypsk%S4+^4j#l)@$ z!gUeoExox_RfAK5=&b*tvm*_4(fRm_NmUH;!ON`>u#ir}zxOL%;}Wl!;VnEQRyS5* z_#|Yg`U3VsEAj_Lzfgp=SREMT^1vX06tWdT)OL7flUf7-Vt1CBM*8_OQVk4R+z!z= znHfaeCowKTZsXf&N{s5or0#1mk9=pU1-QIIGqL zJGazMG(KRVOU2+uK(r%Y3SS<>#F>4q(WV@~=tVYqp;vsrWnL5)nChc-)fMwGV&>tQ zI}9k*d2*rcESqffV@=NEla2OmC{&2U?X_nIY>eaDA|ni_23j6qm0ON{*ySPHehy`B?Ap0x9gI zL>!++_9Wz2>Wh&*Ngc69G)zi;5<);rz%+7Bb9&A&YSX9r3lkdNV%Vi(DztI6r*;WU z+WhF9ON{osc%;LI8$j4PdGTk*h_S<2O$6FGfyFmQa@ovIv3Y^00G! zu5s}NB;Q<9XbQ;EW^pcV{YbL38< zR$+{vK$|D|W*bEVuls8GVfxGuNrOb5KdRD&K)*o0Skc#9`h=PRJ@q*SuNW7!qH)m< ztDXyKSUcCgV$2GWWIAFr(+&=XCz+lr78>XE#&6h%&gTr=&T5FrdABo$$ZR=qOMN}C z(HwEEoeh8Q%m%ZAle5TZLyoFeim3Ql&=#{xcW3w_V`L9GxpYs=7sOWgfO~k2y16?} z0vQt9nG&-v3L<6>wbtew9=EI{Ppb|+G0jOmTvP|;r>aF^pj9dO5Zpm;S71_?`c zJ}zI}AIx%gRvE+bP2Z3<0HFoCfFbtP29Zl%B=^+@DIVp%+90emA$-aP9tXi6r&uF) z&0xi7S=%1xdT1te&7C|CG(^pWa(8VATn1_xJoXX3(JVYo@Dg@bHDhb{-Ni;n5jGov z&=C3hB5XFwd3sl{LofUWZFhT9hRa3;qyr+uWutIpB?{VD{EYKWVBw3LA7{bKzwvTo zq%#-q8;l-@RTG&K#IQozc=25iaYh1k$E%jgVApun8#3569=$==V-TjFN8~{+9$(){576B?`oZMEP(MK8tHyIbnRT^yTtDIRE7^S@UpDkA|F+!{$RB4BB&7$_oXyqJlqRTbK%Avbh zIZPQY(>;ekts^p2K`)_rs-5v~xf9C~mb4tn`t@>T9ka8YH|nAJ_tqF2l&R#aaAoLm ze;eo6a6}&ASQKR|Ga2yp5j&H@BDQs&tTm>k;(VLfmnMq{gMIh<-~i{pD)7k`dAd-U zKE$?ZlnSe!?wp)t4DOb$dQDpObfpb|Am(&v0|kY|<+%`!;Cx5c(z)fkfKYLz?WHOvDjg1ciXKOhka__&nXcM6CGgD~yZ#XRG)w za8Rslbz1`vYRkrF(IkDcU)k6S7FUGno*K5>(&~*HV!4Upw0oPIC{6=4HzZXD`B9uM zF44^tAMJI9`Sftdr1g|?gXne+ZUfP6AJyq%tApB0r&Pm<%IK787+glO>o0bZh>rX*oV(S)%@piW5?&@HObk$=;tgzGO?Yw}xwSO|E$VKo%1cUNua zuBHkQM#FtNWu=SwjPSJ#PJeY3R(kZ@wN&*;Lv0i8B)LnA?*F!oJa@rJ-lBMK?bdrVN zFCL^*V+1FTf|NMx8jN7GTBsmZQo z;LnEi*;-4VO)PYlEH$!H3dBJbm?7Jj=9FD)OpK94Y&d5$6$(?7f@8|L-Vz2~55~^v zdt`%9@qGy)MnE7z{v8Qbnk{lh6$GKCgyca1q)DNsWOlcEiu%ZAr8-qt8@*z`c2?!( zM`_kl;dZE-lp$Yh3cw0+MHbcKBPoJclA2^yz5_3MKwPY=prtWJ2gZvCbWjMRfj+c( zB|g203k~$>JK`yY3l}AYF+yk#?RP>!;Tj^0k?*X%*2rVF(`t*qt+VqUBRwW>Z=&rv z`~p{E$u$WjaRVB7#RB;f5agGW7%k+E<#g*QBqlC3X*ueYJ4F?crcSvhVhlOwO`m55 z)YAH7w)6PvpjcYtO7b$J)OmDqrbD^9+n=K{;5>zGF>M#AY4e&GDp~ivl@oTy zikKa-GR_m3pfIhS%eDl=&Zpm7?bF^-LBxDtXBOTsm~ZQRc8&30xUE}ccXf5O(0OEq zQF>uvLe*%f7OI1X&}K-b5Faq7!6^-Mp*r$RrWk2?1I{tbT48>F(KP5D%r-TxT}hF0 zK!77;Vu3(|xkxpVZsXyg8X7sYq+KFE5owo*1d#jCPPG@;>_S=xYHzOdOUy819TJ7e zh3J4AUy^4MQU{oqGSOlPsS{3O|8K@Wa4`?k=)`4!77!?RYAt62acNKMq-Fy)fR03I zoz!%IL}|G?bsA}Zs-~$@UpWgOOb+Kt<#+ZN{?`AGgSuqNk_J(P1{c0qCBBY~knOza zV);b_@vII$E+MAzb4n<4D2x<+he6D-kVh%b?a_5g%z#*u;gfs4yx5YcWj?NfHPJ_} z5a<$Qox5Y$yheUFWWQeDiDfL&La%kl*GA44lu=Dj_%fqB%KxV^TQ_8@{5sBOlY#A- znDyznKu=|0;qg+1${hg&UV18b1Q5Epr*cOK60?5KzS9!Rk=rtzj7B3rP~QCt+A3dK zPV>I=%QD0cQ?>@rwYJyp;~lb#JJ}f`jw0r$X;BnwXmm1W8QC4D*rDWmfb-B?gPjE3JmG)Bp_+gVQDt|Yd7re{&q)=o)Ib$+-nnCJZA62lI;5B|XI+MAiI;@*bs2 z%ccIC(vcAtm?*p?0##bLSUMZdp397IOuWn`0#neb|LdR?b~7n7C4yGk|JT>m#I{jH z;p}?HaW_rYi7hr=uTwV;m2p}d$23qReo|H9r*0Y!lnM%I;+RsJB1+PtTCy74jlR3yxB#MIyD>s+4z;*)2l5w8+p19A{^RxOMnaM088!e?C@M4(hnBzqaLP6oH6g3D1h3`-V*C%;LQR*1Bg2z_5%873hTNrZ7 zQ!~QvDS;)-ldSd1^5pcoFJ`faj&(5_(uC059hih~hD5cBT3Iz%csOc3P z6dF*|D>x|9W#Ob+!HH74^;-U6bAy%Jj^|W>6(#CK=7{_7f2EhF4jy_*9)3Hyyp#L)k1s-4HgHNWqG+pFz9umJHUcCKH@&;ybqmC`V%wKc=5u?DPZ z^BUit8+^}lJ&jxAvVA!7sLM^_oQPcd)!70MIxjZ6S_{zBNoI;BKlHaMnZMU6kvn;SC@bK?a5=KxMArIv>1zGS$j;W!?GnNIfzSrDPvf%BT z*Y!hmkq2!HnFD-+S9_*_U7<Ux=<~{1fq-Shk3(VO3kI}pyRTK~rK Uiolh`)rl*GYhARw;$HvbA84AHV*mgE delta 38532 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ŨdCURD!?MW|;f} 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 From 385e32cfbbc27ac3db0a03d2469fcecdc6f24111 Mon Sep 17 00:00:00 2001 From: Luca Joss Date: Tue, 20 Aug 2024 17:13:48 +0200 Subject: [PATCH 3/3] Add ibc core commitment v2 --- src/lib.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/lib.rs b/src/lib.rs index 5f2843a5..296a28d3 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 {