diff --git a/cosmos-sdk-proto/src/prost/ibc-go/cosmos.auth.v1beta1.rs b/cosmos-sdk-proto/src/prost/ibc-go/cosmos.auth.v1beta1.rs
index 272e77e9..06136eb1 100644
--- a/cosmos-sdk-proto/src/prost/ibc-go/cosmos.auth.v1beta1.rs
+++ b/cosmos-sdk-proto/src/prost/ibc-go/cosmos.auth.v1beta1.rs
@@ -1,4 +1,4 @@
-// This file is @generated by prost-build.
+// @generated
 /// BaseAccount defines a base account type. It contains all the necessary fields
 /// for basic account functionality. Any custom account type should extend this
 /// type for additional functionality (e.g. vesting).
@@ -14,16 +14,6 @@ pub struct BaseAccount {
     #[prost(uint64, tag = "4")]
     pub sequence: u64,
 }
-impl ::prost::Name for BaseAccount {
-    const NAME: &'static str = "BaseAccount";
-    const PACKAGE: &'static str = "cosmos.auth.v1beta1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "cosmos.auth.v1beta1.BaseAccount".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/cosmos.auth.v1beta1.BaseAccount".into()
-    }
-}
 /// ModuleAccount defines an account for modules that holds coins on a pool.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -35,19 +25,9 @@ pub struct ModuleAccount {
     #[prost(string, repeated, tag = "3")]
     pub permissions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
 }
-impl ::prost::Name for ModuleAccount {
-    const NAME: &'static str = "ModuleAccount";
-    const PACKAGE: &'static str = "cosmos.auth.v1beta1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "cosmos.auth.v1beta1.ModuleAccount".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/cosmos.auth.v1beta1.ModuleAccount".into()
-    }
-}
 /// Params defines the parameters for the auth module.
 #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Params {
     #[prost(uint64, tag = "1")]
     pub max_memo_characters: u64,
@@ -60,13 +40,5 @@ pub struct Params {
     #[prost(uint64, tag = "5")]
     pub sig_verify_cost_secp256k1: u64,
 }
-impl ::prost::Name for Params {
-    const NAME: &'static str = "Params";
-    const PACKAGE: &'static str = "cosmos.auth.v1beta1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "cosmos.auth.v1beta1.Params".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/cosmos.auth.v1beta1.Params".into()
-    }
-}
+include!("cosmos.auth.v1beta1.serde.rs");
+// @@protoc_insertion_point(module)
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/cosmos.auth.v1beta1.serde.rs b/cosmos-sdk-proto/src/prost/ibc-go/cosmos.auth.v1beta1.serde.rs
new file mode 100644
index 00000000..ea25be70
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/cosmos.auth.v1beta1.serde.rs
@@ -0,0 +1,511 @@
+// @generated
+#[cfg(feature = "serde")]
+impl serde::Serialize for BaseAccount {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.address.is_empty() {
+            len += 1;
+        }
+        if self.pub_key.is_some() {
+            len += 1;
+        }
+        if self.account_number != 0 {
+            len += 1;
+        }
+        if self.sequence != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("cosmos.auth.v1beta1.BaseAccount", len)?;
+        if !self.address.is_empty() {
+            struct_ser.serialize_field("address", &self.address)?;
+        }
+        if let Some(v) = self.pub_key.as_ref() {
+            struct_ser.serialize_field("pubKey", v)?;
+        }
+        if self.account_number != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "accountNumber",
+                ToString::to_string(&self.account_number).as_str(),
+            )?;
+        }
+        if self.sequence != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("sequence", ToString::to_string(&self.sequence).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for BaseAccount {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "address",
+            "pub_key",
+            "pubKey",
+            "account_number",
+            "accountNumber",
+            "sequence",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Address,
+            PubKey,
+            AccountNumber,
+            Sequence,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "address" => Ok(GeneratedField::Address),
+                            "pubKey" | "pub_key" => Ok(GeneratedField::PubKey),
+                            "accountNumber" | "account_number" => Ok(GeneratedField::AccountNumber),
+                            "sequence" => Ok(GeneratedField::Sequence),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = BaseAccount;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct cosmos.auth.v1beta1.BaseAccount")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<BaseAccount, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut address__ = None;
+                let mut pub_key__ = None;
+                let mut account_number__ = None;
+                let mut sequence__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Address => {
+                            if address__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("address"));
+                            }
+                            address__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::PubKey => {
+                            if pub_key__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("pubKey"));
+                            }
+                            pub_key__ = map_.next_value()?;
+                        }
+                        GeneratedField::AccountNumber => {
+                            if account_number__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("accountNumber"));
+                            }
+                            account_number__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Sequence => {
+                            if sequence__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sequence"));
+                            }
+                            sequence__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(BaseAccount {
+                    address: address__.unwrap_or_default(),
+                    pub_key: pub_key__,
+                    account_number: account_number__.unwrap_or_default(),
+                    sequence: sequence__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("cosmos.auth.v1beta1.BaseAccount", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for ModuleAccount {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.base_account.is_some() {
+            len += 1;
+        }
+        if !self.name.is_empty() {
+            len += 1;
+        }
+        if !self.permissions.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("cosmos.auth.v1beta1.ModuleAccount", len)?;
+        if let Some(v) = self.base_account.as_ref() {
+            struct_ser.serialize_field("baseAccount", v)?;
+        }
+        if !self.name.is_empty() {
+            struct_ser.serialize_field("name", &self.name)?;
+        }
+        if !self.permissions.is_empty() {
+            struct_ser.serialize_field("permissions", &self.permissions)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ModuleAccount {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["base_account", "baseAccount", "name", "permissions"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            BaseAccount,
+            Name,
+            Permissions,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "baseAccount" | "base_account" => Ok(GeneratedField::BaseAccount),
+                            "name" => Ok(GeneratedField::Name),
+                            "permissions" => Ok(GeneratedField::Permissions),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ModuleAccount;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct cosmos.auth.v1beta1.ModuleAccount")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ModuleAccount, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut base_account__ = None;
+                let mut name__ = None;
+                let mut permissions__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::BaseAccount => {
+                            if base_account__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("baseAccount"));
+                            }
+                            base_account__ = map_.next_value()?;
+                        }
+                        GeneratedField::Name => {
+                            if name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("name"));
+                            }
+                            name__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Permissions => {
+                            if permissions__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("permissions"));
+                            }
+                            permissions__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(ModuleAccount {
+                    base_account: base_account__,
+                    name: name__.unwrap_or_default(),
+                    permissions: permissions__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "cosmos.auth.v1beta1.ModuleAccount",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Params {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.max_memo_characters != 0 {
+            len += 1;
+        }
+        if self.tx_sig_limit != 0 {
+            len += 1;
+        }
+        if self.tx_size_cost_per_byte != 0 {
+            len += 1;
+        }
+        if self.sig_verify_cost_ed25519 != 0 {
+            len += 1;
+        }
+        if self.sig_verify_cost_secp256k1 != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("cosmos.auth.v1beta1.Params", len)?;
+        if self.max_memo_characters != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "maxMemoCharacters",
+                ToString::to_string(&self.max_memo_characters).as_str(),
+            )?;
+        }
+        if self.tx_sig_limit != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "txSigLimit",
+                ToString::to_string(&self.tx_sig_limit).as_str(),
+            )?;
+        }
+        if self.tx_size_cost_per_byte != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "txSizeCostPerByte",
+                ToString::to_string(&self.tx_size_cost_per_byte).as_str(),
+            )?;
+        }
+        if self.sig_verify_cost_ed25519 != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "sigVerifyCostEd25519",
+                ToString::to_string(&self.sig_verify_cost_ed25519).as_str(),
+            )?;
+        }
+        if self.sig_verify_cost_secp256k1 != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "sigVerifyCostSecp256k1",
+                ToString::to_string(&self.sig_verify_cost_secp256k1).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Params {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "max_memo_characters",
+            "maxMemoCharacters",
+            "tx_sig_limit",
+            "txSigLimit",
+            "tx_size_cost_per_byte",
+            "txSizeCostPerByte",
+            "sig_verify_cost_ed25519",
+            "sigVerifyCostEd25519",
+            "sig_verify_cost_secp256k1",
+            "sigVerifyCostSecp256k1",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            MaxMemoCharacters,
+            TxSigLimit,
+            TxSizeCostPerByte,
+            SigVerifyCostEd25519,
+            SigVerifyCostSecp256k1,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "maxMemoCharacters" | "max_memo_characters" => {
+                                Ok(GeneratedField::MaxMemoCharacters)
+                            }
+                            "txSigLimit" | "tx_sig_limit" => Ok(GeneratedField::TxSigLimit),
+                            "txSizeCostPerByte" | "tx_size_cost_per_byte" => {
+                                Ok(GeneratedField::TxSizeCostPerByte)
+                            }
+                            "sigVerifyCostEd25519" | "sig_verify_cost_ed25519" => {
+                                Ok(GeneratedField::SigVerifyCostEd25519)
+                            }
+                            "sigVerifyCostSecp256k1" | "sig_verify_cost_secp256k1" => {
+                                Ok(GeneratedField::SigVerifyCostSecp256k1)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Params;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct cosmos.auth.v1beta1.Params")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Params, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut max_memo_characters__ = None;
+                let mut tx_sig_limit__ = None;
+                let mut tx_size_cost_per_byte__ = None;
+                let mut sig_verify_cost_ed25519__ = None;
+                let mut sig_verify_cost_secp256k1__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::MaxMemoCharacters => {
+                            if max_memo_characters__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("maxMemoCharacters"));
+                            }
+                            max_memo_characters__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::TxSigLimit => {
+                            if tx_sig_limit__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("txSigLimit"));
+                            }
+                            tx_sig_limit__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::TxSizeCostPerByte => {
+                            if tx_size_cost_per_byte__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("txSizeCostPerByte"));
+                            }
+                            tx_size_cost_per_byte__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::SigVerifyCostEd25519 => {
+                            if sig_verify_cost_ed25519__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "sigVerifyCostEd25519",
+                                ));
+                            }
+                            sig_verify_cost_ed25519__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::SigVerifyCostSecp256k1 => {
+                            if sig_verify_cost_secp256k1__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "sigVerifyCostSecp256k1",
+                                ));
+                            }
+                            sig_verify_cost_secp256k1__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(Params {
+                    max_memo_characters: max_memo_characters__.unwrap_or_default(),
+                    tx_sig_limit: tx_sig_limit__.unwrap_or_default(),
+                    tx_size_cost_per_byte: tx_size_cost_per_byte__.unwrap_or_default(),
+                    sig_verify_cost_ed25519: sig_verify_cost_ed25519__.unwrap_or_default(),
+                    sig_verify_cost_secp256k1: sig_verify_cost_secp256k1__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("cosmos.auth.v1beta1.Params", FIELDS, GeneratedVisitor)
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/cosmos.base.query.v1beta1.rs b/cosmos-sdk-proto/src/prost/ibc-go/cosmos.base.query.v1beta1.rs
index dc11f529..9e79d078 100644
--- a/cosmos-sdk-proto/src/prost/ibc-go/cosmos.base.query.v1beta1.rs
+++ b/cosmos-sdk-proto/src/prost/ibc-go/cosmos.base.query.v1beta1.rs
@@ -1,4 +1,4 @@
-// This file is @generated by prost-build.
+// @generated
 /// PageRequest is to be embedded in gRPC request messages for efficient
 /// pagination. Ex:
 ///
@@ -35,16 +35,6 @@ pub struct PageRequest {
     #[prost(bool, tag = "5")]
     pub reverse: bool,
 }
-impl ::prost::Name for PageRequest {
-    const NAME: &'static str = "PageRequest";
-    const PACKAGE: &'static str = "cosmos.base.query.v1beta1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "cosmos.base.query.v1beta1.PageRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/cosmos.base.query.v1beta1.PageRequest".into()
-    }
-}
 /// PageResponse is to be embedded in gRPC response messages where the
 /// corresponding request message has used PageRequest.
 ///
@@ -65,13 +55,5 @@ pub struct PageResponse {
     #[prost(uint64, tag = "2")]
     pub total: u64,
 }
-impl ::prost::Name for PageResponse {
-    const NAME: &'static str = "PageResponse";
-    const PACKAGE: &'static str = "cosmos.base.query.v1beta1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "cosmos.base.query.v1beta1.PageResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/cosmos.base.query.v1beta1.PageResponse".into()
-    }
-}
+include!("cosmos.base.query.v1beta1.serde.rs");
+// @@protoc_insertion_point(module)
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/cosmos.base.query.v1beta1.serde.rs b/cosmos-sdk-proto/src/prost/ibc-go/cosmos.base.query.v1beta1.serde.rs
new file mode 100644
index 00000000..27639f3d
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/cosmos.base.query.v1beta1.serde.rs
@@ -0,0 +1,312 @@
+// @generated
+#[cfg(feature = "serde")]
+impl serde::Serialize for PageRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.key.is_empty() {
+            len += 1;
+        }
+        if self.offset != 0 {
+            len += 1;
+        }
+        if self.limit != 0 {
+            len += 1;
+        }
+        if self.count_total {
+            len += 1;
+        }
+        if self.reverse {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("cosmos.base.query.v1beta1.PageRequest", len)?;
+        if !self.key.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?;
+        }
+        if self.offset != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
+        }
+        if self.limit != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
+        }
+        if self.count_total {
+            struct_ser.serialize_field("countTotal", &self.count_total)?;
+        }
+        if self.reverse {
+            struct_ser.serialize_field("reverse", &self.reverse)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for PageRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "key",
+            "offset",
+            "limit",
+            "count_total",
+            "countTotal",
+            "reverse",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Key,
+            Offset,
+            Limit,
+            CountTotal,
+            Reverse,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "key" => Ok(GeneratedField::Key),
+                            "offset" => Ok(GeneratedField::Offset),
+                            "limit" => Ok(GeneratedField::Limit),
+                            "countTotal" | "count_total" => Ok(GeneratedField::CountTotal),
+                            "reverse" => Ok(GeneratedField::Reverse),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PageRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct cosmos.base.query.v1beta1.PageRequest")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PageRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut key__ = None;
+                let mut offset__ = None;
+                let mut limit__ = None;
+                let mut count_total__ = None;
+                let mut reverse__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Key => {
+                            if key__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("key"));
+                            }
+                            key__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Offset => {
+                            if offset__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("offset"));
+                            }
+                            offset__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Limit => {
+                            if limit__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("limit"));
+                            }
+                            limit__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::CountTotal => {
+                            if count_total__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("countTotal"));
+                            }
+                            count_total__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Reverse => {
+                            if reverse__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("reverse"));
+                            }
+                            reverse__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(PageRequest {
+                    key: key__.unwrap_or_default(),
+                    offset: offset__.unwrap_or_default(),
+                    limit: limit__.unwrap_or_default(),
+                    count_total: count_total__.unwrap_or_default(),
+                    reverse: reverse__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "cosmos.base.query.v1beta1.PageRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for PageResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.next_key.is_empty() {
+            len += 1;
+        }
+        if self.total != 0 {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("cosmos.base.query.v1beta1.PageResponse", len)?;
+        if !self.next_key.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "nextKey",
+                pbjson::private::base64::encode(&self.next_key).as_str(),
+            )?;
+        }
+        if self.total != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("total", ToString::to_string(&self.total).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for PageResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["next_key", "nextKey", "total"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            NextKey,
+            Total,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "nextKey" | "next_key" => Ok(GeneratedField::NextKey),
+                            "total" => Ok(GeneratedField::Total),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PageResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct cosmos.base.query.v1beta1.PageResponse")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PageResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut next_key__ = None;
+                let mut total__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::NextKey => {
+                            if next_key__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("nextKey"));
+                            }
+                            next_key__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Total => {
+                            if total__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("total"));
+                            }
+                            total__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(PageResponse {
+                    next_key: next_key__.unwrap_or_default(),
+                    total: total__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "cosmos.base.query.v1beta1.PageResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/cosmos.base.v1beta1.rs b/cosmos-sdk-proto/src/prost/ibc-go/cosmos.base.v1beta1.rs
index 057afb09..8a02bbd7 100644
--- a/cosmos-sdk-proto/src/prost/ibc-go/cosmos.base.v1beta1.rs
+++ b/cosmos-sdk-proto/src/prost/ibc-go/cosmos.base.v1beta1.rs
@@ -1,4 +1,4 @@
-// This file is @generated by prost-build.
+// @generated
 /// Coin defines a token with a denomination and an amount.
 ///
 /// NOTE: The amount field is an Int which implements the custom method
@@ -11,16 +11,6 @@ pub struct Coin {
     #[prost(string, tag = "2")]
     pub amount: ::prost::alloc::string::String,
 }
-impl ::prost::Name for Coin {
-    const NAME: &'static str = "Coin";
-    const PACKAGE: &'static str = "cosmos.base.v1beta1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "cosmos.base.v1beta1.Coin".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/cosmos.base.v1beta1.Coin".into()
-    }
-}
 /// DecCoin defines a token with a denomination and a decimal amount.
 ///
 /// NOTE: The amount field is an Dec which implements the custom method
@@ -33,16 +23,6 @@ pub struct DecCoin {
     #[prost(string, tag = "2")]
     pub amount: ::prost::alloc::string::String,
 }
-impl ::prost::Name for DecCoin {
-    const NAME: &'static str = "DecCoin";
-    const PACKAGE: &'static str = "cosmos.base.v1beta1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "cosmos.base.v1beta1.DecCoin".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/cosmos.base.v1beta1.DecCoin".into()
-    }
-}
 /// IntProto defines a Protobuf wrapper around an Int object.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -50,16 +30,6 @@ pub struct IntProto {
     #[prost(string, tag = "1")]
     pub int: ::prost::alloc::string::String,
 }
-impl ::prost::Name for IntProto {
-    const NAME: &'static str = "IntProto";
-    const PACKAGE: &'static str = "cosmos.base.v1beta1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "cosmos.base.v1beta1.IntProto".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/cosmos.base.v1beta1.IntProto".into()
-    }
-}
 /// DecProto defines a Protobuf wrapper around a Dec object.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -67,13 +37,5 @@ pub struct DecProto {
     #[prost(string, tag = "1")]
     pub dec: ::prost::alloc::string::String,
 }
-impl ::prost::Name for DecProto {
-    const NAME: &'static str = "DecProto";
-    const PACKAGE: &'static str = "cosmos.base.v1beta1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "cosmos.base.v1beta1.DecProto".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/cosmos.base.v1beta1.DecProto".into()
-    }
-}
+include!("cosmos.base.v1beta1.serde.rs");
+// @@protoc_insertion_point(module)
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/cosmos.base.v1beta1.serde.rs b/cosmos-sdk-proto/src/prost/ibc-go/cosmos.base.v1beta1.serde.rs
new file mode 100644
index 00000000..92880130
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/cosmos.base.v1beta1.serde.rs
@@ -0,0 +1,413 @@
+// @generated
+#[cfg(feature = "serde")]
+impl serde::Serialize for Coin {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.denom.is_empty() {
+            len += 1;
+        }
+        if !self.amount.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("cosmos.base.v1beta1.Coin", len)?;
+        if !self.denom.is_empty() {
+            struct_ser.serialize_field("denom", &self.denom)?;
+        }
+        if !self.amount.is_empty() {
+            struct_ser.serialize_field("amount", &self.amount)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Coin {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["denom", "amount"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Denom,
+            Amount,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "denom" => Ok(GeneratedField::Denom),
+                            "amount" => Ok(GeneratedField::Amount),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Coin;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct cosmos.base.v1beta1.Coin")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Coin, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut denom__ = None;
+                let mut amount__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Denom => {
+                            if denom__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("denom"));
+                            }
+                            denom__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Amount => {
+                            if amount__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("amount"));
+                            }
+                            amount__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(Coin {
+                    denom: denom__.unwrap_or_default(),
+                    amount: amount__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("cosmos.base.v1beta1.Coin", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for DecCoin {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.denom.is_empty() {
+            len += 1;
+        }
+        if !self.amount.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("cosmos.base.v1beta1.DecCoin", len)?;
+        if !self.denom.is_empty() {
+            struct_ser.serialize_field("denom", &self.denom)?;
+        }
+        if !self.amount.is_empty() {
+            struct_ser.serialize_field("amount", &self.amount)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for DecCoin {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["denom", "amount"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Denom,
+            Amount,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "denom" => Ok(GeneratedField::Denom),
+                            "amount" => Ok(GeneratedField::Amount),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = DecCoin;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct cosmos.base.v1beta1.DecCoin")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DecCoin, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut denom__ = None;
+                let mut amount__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Denom => {
+                            if denom__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("denom"));
+                            }
+                            denom__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Amount => {
+                            if amount__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("amount"));
+                            }
+                            amount__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(DecCoin {
+                    denom: denom__.unwrap_or_default(),
+                    amount: amount__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("cosmos.base.v1beta1.DecCoin", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for DecProto {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.dec.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("cosmos.base.v1beta1.DecProto", len)?;
+        if !self.dec.is_empty() {
+            struct_ser.serialize_field("dec", &self.dec)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for DecProto {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["dec"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Dec,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "dec" => Ok(GeneratedField::Dec),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = DecProto;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct cosmos.base.v1beta1.DecProto")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DecProto, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut dec__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Dec => {
+                            if dec__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("dec"));
+                            }
+                            dec__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(DecProto {
+                    dec: dec__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("cosmos.base.v1beta1.DecProto", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for IntProto {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.int.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("cosmos.base.v1beta1.IntProto", len)?;
+        if !self.int.is_empty() {
+            struct_ser.serialize_field("int", &self.int)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for IntProto {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["int"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Int,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "int" => Ok(GeneratedField::Int),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = IntProto;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct cosmos.base.v1beta1.IntProto")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<IntProto, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut int__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Int => {
+                            if int__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("int"));
+                            }
+                            int__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(IntProto {
+                    int: int__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("cosmos.base.v1beta1.IntProto", FIELDS, GeneratedVisitor)
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/cosmos.upgrade.v1beta1.rs b/cosmos-sdk-proto/src/prost/ibc-go/cosmos.upgrade.v1beta1.rs
index 53f4a7d3..72c6d53b 100644
--- a/cosmos-sdk-proto/src/prost/ibc-go/cosmos.upgrade.v1beta1.rs
+++ b/cosmos-sdk-proto/src/prost/ibc-go/cosmos.upgrade.v1beta1.rs
@@ -1,4 +1,4 @@
-// This file is @generated by prost-build.
+// @generated
 /// Plan specifies information about a planned upgrade and when it should occur.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -33,16 +33,6 @@ pub struct Plan {
     #[prost(message, optional, tag = "5")]
     pub upgraded_client_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
 }
-impl ::prost::Name for Plan {
-    const NAME: &'static str = "Plan";
-    const PACKAGE: &'static str = "cosmos.upgrade.v1beta1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "cosmos.upgrade.v1beta1.Plan".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/cosmos.upgrade.v1beta1.Plan".into()
-    }
-}
 /// SoftwareUpgradeProposal is a gov Content type for initiating a software
 /// upgrade.
 /// Deprecated: This legacy proposal is deprecated in favor of Msg-based gov
@@ -57,16 +47,6 @@ pub struct SoftwareUpgradeProposal {
     #[prost(message, optional, tag = "3")]
     pub plan: ::core::option::Option<Plan>,
 }
-impl ::prost::Name for SoftwareUpgradeProposal {
-    const NAME: &'static str = "SoftwareUpgradeProposal";
-    const PACKAGE: &'static str = "cosmos.upgrade.v1beta1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "cosmos.upgrade.v1beta1.SoftwareUpgradeProposal".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/cosmos.upgrade.v1beta1.SoftwareUpgradeProposal".into()
-    }
-}
 /// CancelSoftwareUpgradeProposal is a gov Content type for cancelling a software
 /// upgrade.
 /// Deprecated: This legacy proposal is deprecated in favor of Msg-based gov
@@ -79,16 +59,6 @@ pub struct CancelSoftwareUpgradeProposal {
     #[prost(string, tag = "2")]
     pub description: ::prost::alloc::string::String,
 }
-impl ::prost::Name for CancelSoftwareUpgradeProposal {
-    const NAME: &'static str = "CancelSoftwareUpgradeProposal";
-    const PACKAGE: &'static str = "cosmos.upgrade.v1beta1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "cosmos.upgrade.v1beta1.CancelSoftwareUpgradeProposal".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/cosmos.upgrade.v1beta1.CancelSoftwareUpgradeProposal".into()
-    }
-}
 /// ModuleVersion specifies a module and its consensus version.
 ///
 /// Since: cosmos-sdk 0.43
@@ -102,13 +72,5 @@ pub struct ModuleVersion {
     #[prost(uint64, tag = "2")]
     pub version: u64,
 }
-impl ::prost::Name for ModuleVersion {
-    const NAME: &'static str = "ModuleVersion";
-    const PACKAGE: &'static str = "cosmos.upgrade.v1beta1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "cosmos.upgrade.v1beta1.ModuleVersion".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/cosmos.upgrade.v1beta1.ModuleVersion".into()
-    }
-}
+include!("cosmos.upgrade.v1beta1.serde.rs");
+// @@protoc_insertion_point(module)
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/cosmos.upgrade.v1beta1.serde.rs b/cosmos-sdk-proto/src/prost/ibc-go/cosmos.upgrade.v1beta1.serde.rs
new file mode 100644
index 00000000..805334b6
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/cosmos.upgrade.v1beta1.serde.rs
@@ -0,0 +1,549 @@
+// @generated
+#[cfg(feature = "serde")]
+impl serde::Serialize for CancelSoftwareUpgradeProposal {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.title.is_empty() {
+            len += 1;
+        }
+        if !self.description.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("cosmos.upgrade.v1beta1.CancelSoftwareUpgradeProposal", len)?;
+        if !self.title.is_empty() {
+            struct_ser.serialize_field("title", &self.title)?;
+        }
+        if !self.description.is_empty() {
+            struct_ser.serialize_field("description", &self.description)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for CancelSoftwareUpgradeProposal {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["title", "description"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Title,
+            Description,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "title" => Ok(GeneratedField::Title),
+                            "description" => Ok(GeneratedField::Description),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = CancelSoftwareUpgradeProposal;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct cosmos.upgrade.v1beta1.CancelSoftwareUpgradeProposal")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<CancelSoftwareUpgradeProposal, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut title__ = None;
+                let mut description__ = 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()?);
+                        }
+                    }
+                }
+                Ok(CancelSoftwareUpgradeProposal {
+                    title: title__.unwrap_or_default(),
+                    description: description__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "cosmos.upgrade.v1beta1.CancelSoftwareUpgradeProposal",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for ModuleVersion {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.name.is_empty() {
+            len += 1;
+        }
+        if self.version != 0 {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("cosmos.upgrade.v1beta1.ModuleVersion", len)?;
+        if !self.name.is_empty() {
+            struct_ser.serialize_field("name", &self.name)?;
+        }
+        if self.version != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ModuleVersion {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["name", "version"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Name,
+            Version,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "name" => Ok(GeneratedField::Name),
+                            "version" => Ok(GeneratedField::Version),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ModuleVersion;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct cosmos.upgrade.v1beta1.ModuleVersion")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ModuleVersion, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut name__ = None;
+                let mut version__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Name => {
+                            if name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("name"));
+                            }
+                            name__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Version => {
+                            if version__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("version"));
+                            }
+                            version__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(ModuleVersion {
+                    name: name__.unwrap_or_default(),
+                    version: version__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "cosmos.upgrade.v1beta1.ModuleVersion",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Plan {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.name.is_empty() {
+            len += 1;
+        }
+        if self.time.is_some() {
+            len += 1;
+        }
+        if self.height != 0 {
+            len += 1;
+        }
+        if !self.info.is_empty() {
+            len += 1;
+        }
+        if self.upgraded_client_state.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("cosmos.upgrade.v1beta1.Plan", len)?;
+        if !self.name.is_empty() {
+            struct_ser.serialize_field("name", &self.name)?;
+        }
+        if let Some(v) = self.time.as_ref() {
+            struct_ser.serialize_field("time", v)?;
+        }
+        if self.height != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("height", ToString::to_string(&self.height).as_str())?;
+        }
+        if !self.info.is_empty() {
+            struct_ser.serialize_field("info", &self.info)?;
+        }
+        if let Some(v) = self.upgraded_client_state.as_ref() {
+            struct_ser.serialize_field("upgradedClientState", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Plan {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "name",
+            "time",
+            "height",
+            "info",
+            "upgraded_client_state",
+            "upgradedClientState",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Name,
+            Time,
+            Height,
+            Info,
+            UpgradedClientState,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "name" => Ok(GeneratedField::Name),
+                            "time" => Ok(GeneratedField::Time),
+                            "height" => Ok(GeneratedField::Height),
+                            "info" => Ok(GeneratedField::Info),
+                            "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 = Plan;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct cosmos.upgrade.v1beta1.Plan")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Plan, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut name__ = None;
+                let mut time__ = None;
+                let mut height__ = None;
+                let mut info__ = None;
+                let mut upgraded_client_state__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Name => {
+                            if name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("name"));
+                            }
+                            name__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Time => {
+                            if time__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("time"));
+                            }
+                            time__ = map_.next_value()?;
+                        }
+                        GeneratedField::Height => {
+                            if height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("height"));
+                            }
+                            height__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Info => {
+                            if info__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("info"));
+                            }
+                            info__ = Some(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(Plan {
+                    name: name__.unwrap_or_default(),
+                    time: time__,
+                    height: height__.unwrap_or_default(),
+                    info: info__.unwrap_or_default(),
+                    upgraded_client_state: upgraded_client_state__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("cosmos.upgrade.v1beta1.Plan", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for SoftwareUpgradeProposal {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.title.is_empty() {
+            len += 1;
+        }
+        if !self.description.is_empty() {
+            len += 1;
+        }
+        if self.plan.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("cosmos.upgrade.v1beta1.SoftwareUpgradeProposal", len)?;
+        if !self.title.is_empty() {
+            struct_ser.serialize_field("title", &self.title)?;
+        }
+        if !self.description.is_empty() {
+            struct_ser.serialize_field("description", &self.description)?;
+        }
+        if let Some(v) = self.plan.as_ref() {
+            struct_ser.serialize_field("plan", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for SoftwareUpgradeProposal {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["title", "description", "plan"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Title,
+            Description,
+            Plan,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "title" => Ok(GeneratedField::Title),
+                            "description" => Ok(GeneratedField::Description),
+                            "plan" => Ok(GeneratedField::Plan),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = SoftwareUpgradeProposal;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct cosmos.upgrade.v1beta1.SoftwareUpgradeProposal")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<SoftwareUpgradeProposal, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut title__ = None;
+                let mut description__ = None;
+                let mut plan__ = 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()?;
+                        }
+                    }
+                }
+                Ok(SoftwareUpgradeProposal {
+                    title: title__.unwrap_or_default(),
+                    description: description__.unwrap_or_default(),
+                    plan: plan__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "cosmos.upgrade.v1beta1.SoftwareUpgradeProposal",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/cosmos_proto.rs b/cosmos-sdk-proto/src/prost/ibc-go/cosmos_proto.rs
new file mode 100644
index 00000000..8e2ac1be
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/cosmos_proto.rs
@@ -0,0 +1,2 @@
+// @generated
+// @@protoc_insertion_point(module)
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.fee.v1.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.fee.v1.rs
new file mode 100644
index 00000000..2833d799
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.fee.v1.rs
@@ -0,0 +1,427 @@
+// @generated
+/// IncentivizedAcknowledgement is the acknowledgement format to be used by applications wrapped in the fee middleware
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct IncentivizedAcknowledgement {
+    /// the underlying app acknowledgement bytes
+    #[prost(bytes = "vec", tag = "1")]
+    pub app_acknowledgement: ::prost::alloc::vec::Vec<u8>,
+    /// the relayer address which submits the recv packet message
+    #[prost(string, tag = "2")]
+    pub forward_relayer_address: ::prost::alloc::string::String,
+    /// success flag of the base application callback
+    #[prost(bool, tag = "3")]
+    pub underlying_app_success: bool,
+}
+/// Fee defines the ICS29 receive, acknowledgement and timeout fees
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Fee {
+    /// the packet receive fee
+    #[prost(message, repeated, tag = "1")]
+    pub recv_fee: ::prost::alloc::vec::Vec<super::super::super::super::cosmos::base::v1beta1::Coin>,
+    /// the packet acknowledgement fee
+    #[prost(message, repeated, tag = "2")]
+    pub ack_fee: ::prost::alloc::vec::Vec<super::super::super::super::cosmos::base::v1beta1::Coin>,
+    /// the packet timeout fee
+    #[prost(message, repeated, tag = "3")]
+    pub timeout_fee:
+        ::prost::alloc::vec::Vec<super::super::super::super::cosmos::base::v1beta1::Coin>,
+}
+/// PacketFee contains ICS29 relayer fees, refund address and optional list of permitted relayers
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PacketFee {
+    /// fee encapsulates the recv, ack and timeout fees associated with an IBC packet
+    #[prost(message, optional, tag = "1")]
+    pub fee: ::core::option::Option<Fee>,
+    /// the refund address for unspent fees
+    #[prost(string, tag = "2")]
+    pub refund_address: ::prost::alloc::string::String,
+    /// optional list of relayers permitted to receive fees
+    #[prost(string, repeated, tag = "3")]
+    pub relayers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+}
+/// PacketFees contains a list of type PacketFee
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PacketFees {
+    /// list of packet fees
+    #[prost(message, repeated, tag = "1")]
+    pub packet_fees: ::prost::alloc::vec::Vec<PacketFee>,
+}
+/// IdentifiedPacketFees contains a list of type PacketFee and associated PacketId
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct IdentifiedPacketFees {
+    /// unique packet identifier comprised of the channel ID, port ID and sequence
+    #[prost(message, optional, tag = "1")]
+    pub packet_id: ::core::option::Option<super::super::super::core::channel::v1::PacketId>,
+    /// list of packet fees
+    #[prost(message, repeated, tag = "2")]
+    pub packet_fees: ::prost::alloc::vec::Vec<PacketFee>,
+}
+/// GenesisState defines the ICS29 fee middleware genesis state
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GenesisState {
+    /// list of identified packet fees
+    #[prost(message, repeated, tag = "1")]
+    pub identified_fees: ::prost::alloc::vec::Vec<IdentifiedPacketFees>,
+    /// list of fee enabled channels
+    #[prost(message, repeated, tag = "2")]
+    pub fee_enabled_channels: ::prost::alloc::vec::Vec<FeeEnabledChannel>,
+    /// list of registered payees
+    #[prost(message, repeated, tag = "3")]
+    pub registered_payees: ::prost::alloc::vec::Vec<RegisteredPayee>,
+    /// list of registered counterparty payees
+    #[prost(message, repeated, tag = "4")]
+    pub registered_counterparty_payees: ::prost::alloc::vec::Vec<RegisteredCounterpartyPayee>,
+    /// list of forward relayer addresses
+    #[prost(message, repeated, tag = "5")]
+    pub forward_relayers: ::prost::alloc::vec::Vec<ForwardRelayerAddress>,
+}
+/// FeeEnabledChannel contains the PortID & ChannelID for a fee enabled channel
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct FeeEnabledChannel {
+    /// unique port identifier
+    #[prost(string, tag = "1")]
+    pub port_id: ::prost::alloc::string::String,
+    /// unique channel identifier
+    #[prost(string, tag = "2")]
+    pub channel_id: ::prost::alloc::string::String,
+}
+/// RegisteredPayee contains the relayer address and payee address for a specific channel
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct RegisteredPayee {
+    /// unique channel identifier
+    #[prost(string, tag = "1")]
+    pub channel_id: ::prost::alloc::string::String,
+    /// the relayer address
+    #[prost(string, tag = "2")]
+    pub relayer: ::prost::alloc::string::String,
+    /// the payee address
+    #[prost(string, tag = "3")]
+    pub payee: ::prost::alloc::string::String,
+}
+/// RegisteredCounterpartyPayee contains the relayer address and counterparty payee address for a specific channel (used
+/// for recv fee distribution)
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct RegisteredCounterpartyPayee {
+    /// unique channel identifier
+    #[prost(string, tag = "1")]
+    pub channel_id: ::prost::alloc::string::String,
+    /// the relayer address
+    #[prost(string, tag = "2")]
+    pub relayer: ::prost::alloc::string::String,
+    /// the counterparty payee address
+    #[prost(string, tag = "3")]
+    pub counterparty_payee: ::prost::alloc::string::String,
+}
+/// ForwardRelayerAddress contains the forward relayer address and PacketId used for async acknowledgements
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+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
+    #[prost(message, optional, tag = "2")]
+    pub packet_id: ::core::option::Option<super::super::super::core::channel::v1::PacketId>,
+}
+/// Metadata defines the ICS29 channel specific metadata encoded into the channel version bytestring
+/// See ICS004: <https://github.com/cosmos/ibc/tree/master/spec/core/ics-004-channel-and-packet-semantics#Versioning>
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Metadata {
+    /// fee_version defines the ICS29 fee version
+    #[prost(string, tag = "1")]
+    pub fee_version: ::prost::alloc::string::String,
+    /// app_version defines the underlying application version, which may or may not be a JSON encoded bytestring
+    #[prost(string, tag = "2")]
+    pub app_version: ::prost::alloc::string::String,
+}
+/// QueryIncentivizedPacketsRequest defines the request type for the IncentivizedPackets rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryIncentivizedPacketsRequest {
+    /// 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,
+    >,
+    /// block height at which to query
+    #[prost(uint64, tag = "2")]
+    pub query_height: u64,
+}
+/// QueryIncentivizedPacketsResponse defines the response type for the IncentivizedPackets rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryIncentivizedPacketsResponse {
+    /// list of identified fees for incentivized packets
+    #[prost(message, repeated, tag = "1")]
+    pub incentivized_packets: ::prost::alloc::vec::Vec<IdentifiedPacketFees>,
+}
+/// QueryIncentivizedPacketRequest defines the request type for the IncentivizedPacket rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryIncentivizedPacketRequest {
+    /// unique packet identifier comprised of channel ID, port ID and sequence
+    #[prost(message, optional, tag = "1")]
+    pub packet_id: ::core::option::Option<super::super::super::core::channel::v1::PacketId>,
+    /// block height at which to query
+    #[prost(uint64, tag = "2")]
+    pub query_height: u64,
+}
+/// QueryIncentivizedPacketsResponse defines the response type for the IncentivizedPacket rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryIncentivizedPacketResponse {
+    /// the identified fees for the incentivized packet
+    #[prost(message, optional, tag = "1")]
+    pub incentivized_packet: ::core::option::Option<IdentifiedPacketFees>,
+}
+/// QueryIncentivizedPacketsForChannelRequest defines the request 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 QueryIncentivizedPacketsForChannelRequest {
+    /// 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,
+    >,
+    #[prost(string, tag = "2")]
+    pub port_id: ::prost::alloc::string::String,
+    #[prost(string, tag = "3")]
+    pub channel_id: ::prost::alloc::string::String,
+    /// Height to query at
+    #[prost(uint64, tag = "4")]
+    pub query_height: u64,
+}
+/// QueryIncentivizedPacketsResponse defines the response type for the incentivized packets RPC
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryIncentivizedPacketsForChannelResponse {
+    /// Map of all incentivized_packets
+    #[prost(message, repeated, tag = "1")]
+    pub incentivized_packets: ::prost::alloc::vec::Vec<IdentifiedPacketFees>,
+}
+/// QueryTotalRecvFeesRequest defines the request type for the TotalRecvFees rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryTotalRecvFeesRequest {
+    /// the packet identifier for the associated fees
+    #[prost(message, optional, tag = "1")]
+    pub packet_id: ::core::option::Option<super::super::super::core::channel::v1::PacketId>,
+}
+/// QueryTotalRecvFeesResponse defines the response type for the TotalRecvFees rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryTotalRecvFeesResponse {
+    /// the total packet receive fees
+    #[prost(message, repeated, tag = "1")]
+    pub recv_fees:
+        ::prost::alloc::vec::Vec<super::super::super::super::cosmos::base::v1beta1::Coin>,
+}
+/// QueryTotalAckFeesRequest defines the request type for the TotalAckFees rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryTotalAckFeesRequest {
+    /// the packet identifier for the associated fees
+    #[prost(message, optional, tag = "1")]
+    pub packet_id: ::core::option::Option<super::super::super::core::channel::v1::PacketId>,
+}
+/// QueryTotalAckFeesResponse defines the response type for the TotalAckFees rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryTotalAckFeesResponse {
+    /// the total packet acknowledgement fees
+    #[prost(message, repeated, tag = "1")]
+    pub ack_fees: ::prost::alloc::vec::Vec<super::super::super::super::cosmos::base::v1beta1::Coin>,
+}
+/// QueryTotalTimeoutFeesRequest defines the request type for the TotalTimeoutFees rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryTotalTimeoutFeesRequest {
+    /// the packet identifier for the associated fees
+    #[prost(message, optional, tag = "1")]
+    pub packet_id: ::core::option::Option<super::super::super::core::channel::v1::PacketId>,
+}
+/// QueryTotalTimeoutFeesResponse defines the response type for the TotalTimeoutFees rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryTotalTimeoutFeesResponse {
+    /// the total packet timeout fees
+    #[prost(message, repeated, tag = "1")]
+    pub timeout_fees:
+        ::prost::alloc::vec::Vec<super::super::super::super::cosmos::base::v1beta1::Coin>,
+}
+/// QueryPayeeRequest defines the request type for the Payee rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryPayeeRequest {
+    /// unique channel identifier
+    #[prost(string, tag = "1")]
+    pub channel_id: ::prost::alloc::string::String,
+    /// the relayer address to which the distribution address is registered
+    #[prost(string, tag = "2")]
+    pub relayer: ::prost::alloc::string::String,
+}
+/// QueryPayeeResponse defines the response type for the Payee rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryPayeeResponse {
+    /// the payee address to which packet fees are paid out
+    #[prost(string, tag = "1")]
+    pub payee_address: ::prost::alloc::string::String,
+}
+/// QueryCounterpartyPayeeRequest defines the request type for the CounterpartyPayee rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryCounterpartyPayeeRequest {
+    /// unique channel identifier
+    #[prost(string, tag = "1")]
+    pub channel_id: ::prost::alloc::string::String,
+    /// the relayer address to which the counterparty is registered
+    #[prost(string, tag = "2")]
+    pub relayer: ::prost::alloc::string::String,
+}
+/// QueryCounterpartyPayeeResponse defines the response type for the CounterpartyPayee rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryCounterpartyPayeeResponse {
+    /// the counterparty payee address used to compensate forward relaying
+    #[prost(string, tag = "1")]
+    pub counterparty_payee: ::prost::alloc::string::String,
+}
+/// QueryFeeEnabledChannelsRequest defines the request type for the FeeEnabledChannels rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryFeeEnabledChannelsRequest {
+    /// 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,
+    >,
+    /// block height at which to query
+    #[prost(uint64, tag = "2")]
+    pub query_height: u64,
+}
+/// QueryFeeEnabledChannelsResponse defines the response type for the FeeEnabledChannels rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryFeeEnabledChannelsResponse {
+    /// list of fee enabled channels
+    #[prost(message, repeated, tag = "1")]
+    pub fee_enabled_channels: ::prost::alloc::vec::Vec<FeeEnabledChannel>,
+}
+/// QueryFeeEnabledChannelRequest defines the request type for the FeeEnabledChannel rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryFeeEnabledChannelRequest {
+    /// unique port identifier
+    #[prost(string, tag = "1")]
+    pub port_id: ::prost::alloc::string::String,
+    /// unique channel identifier
+    #[prost(string, tag = "2")]
+    pub channel_id: ::prost::alloc::string::String,
+}
+/// QueryFeeEnabledChannelResponse defines the response type for the FeeEnabledChannel rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryFeeEnabledChannelResponse {
+    /// boolean flag representing the fee enabled channel status
+    #[prost(bool, tag = "1")]
+    pub fee_enabled: bool,
+}
+/// MsgRegisterPayee defines the request type for the RegisterPayee rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgRegisterPayee {
+    /// unique port identifier
+    #[prost(string, tag = "1")]
+    pub port_id: ::prost::alloc::string::String,
+    /// unique channel identifier
+    #[prost(string, tag = "2")]
+    pub channel_id: ::prost::alloc::string::String,
+    /// the relayer address
+    #[prost(string, tag = "3")]
+    pub relayer: ::prost::alloc::string::String,
+    /// the payee address
+    #[prost(string, tag = "4")]
+    pub payee: ::prost::alloc::string::String,
+}
+/// MsgRegisterPayeeResponse defines the response type for the RegisterPayee rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgRegisterPayeeResponse {}
+/// MsgRegisterCounterpartyPayee defines the request type for the RegisterCounterpartyPayee rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgRegisterCounterpartyPayee {
+    /// unique port identifier
+    #[prost(string, tag = "1")]
+    pub port_id: ::prost::alloc::string::String,
+    /// unique channel identifier
+    #[prost(string, tag = "2")]
+    pub channel_id: ::prost::alloc::string::String,
+    /// the relayer address
+    #[prost(string, tag = "3")]
+    pub relayer: ::prost::alloc::string::String,
+    /// the counterparty payee address
+    #[prost(string, tag = "4")]
+    pub counterparty_payee: ::prost::alloc::string::String,
+}
+/// MsgRegisterCounterpartyPayeeResponse defines the response type for the RegisterCounterpartyPayee rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgRegisterCounterpartyPayeeResponse {}
+/// MsgPayPacketFee defines the request type for the PayPacketFee rpc
+/// This Msg can be used to pay for a packet at the next sequence send & should be combined with the Msg that will be
+/// paid for
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgPayPacketFee {
+    /// fee encapsulates the recv, ack and timeout fees associated with an IBC packet
+    #[prost(message, optional, tag = "1")]
+    pub fee: ::core::option::Option<Fee>,
+    /// the source port unique identifier
+    #[prost(string, tag = "2")]
+    pub source_port_id: ::prost::alloc::string::String,
+    /// the source channel unique identifer
+    #[prost(string, tag = "3")]
+    pub source_channel_id: ::prost::alloc::string::String,
+    /// account address to refund fee if necessary
+    #[prost(string, tag = "4")]
+    pub signer: ::prost::alloc::string::String,
+    /// optional list of relayers permitted to the receive packet fees
+    #[prost(string, repeated, tag = "5")]
+    pub relayers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+}
+/// MsgPayPacketFeeResponse defines the response type for the PayPacketFee rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgPayPacketFeeResponse {}
+/// MsgPayPacketFeeAsync defines the request type for the PayPacketFeeAsync rpc
+/// This Msg can be used to pay for a packet at a specified sequence (instead of the next sequence send)
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgPayPacketFeeAsync {
+    /// unique packet identifier comprised of the channel ID, port ID and sequence
+    #[prost(message, optional, tag = "1")]
+    pub packet_id: ::core::option::Option<super::super::super::core::channel::v1::PacketId>,
+    /// the packet fee associated with a particular IBC packet
+    #[prost(message, optional, tag = "2")]
+    pub packet_fee: ::core::option::Option<PacketFee>,
+}
+/// MsgPayPacketFeeAsyncResponse defines the response type for the PayPacketFeeAsync rpc
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgPayPacketFeeAsyncResponse {}
+include!("ibc.applications.fee.v1.serde.rs");
+include!("ibc.applications.fee.v1.tonic.rs");
+// @@protoc_insertion_point(module)
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.fee.v1.serde.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.fee.v1.serde.rs
new file mode 100644
index 00000000..59330340
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.fee.v1.serde.rs
@@ -0,0 +1,4687 @@
+// @generated
+#[cfg(feature = "serde")]
+impl serde::Serialize for Fee {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.recv_fee.is_empty() {
+            len += 1;
+        }
+        if !self.ack_fee.is_empty() {
+            len += 1;
+        }
+        if !self.timeout_fee.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ibc.applications.fee.v1.Fee", len)?;
+        if !self.recv_fee.is_empty() {
+            struct_ser.serialize_field("recvFee", &self.recv_fee)?;
+        }
+        if !self.ack_fee.is_empty() {
+            struct_ser.serialize_field("ackFee", &self.ack_fee)?;
+        }
+        if !self.timeout_fee.is_empty() {
+            struct_ser.serialize_field("timeoutFee", &self.timeout_fee)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Fee {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "recv_fee",
+            "recvFee",
+            "ack_fee",
+            "ackFee",
+            "timeout_fee",
+            "timeoutFee",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            RecvFee,
+            AckFee,
+            TimeoutFee,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "recvFee" | "recv_fee" => Ok(GeneratedField::RecvFee),
+                            "ackFee" | "ack_fee" => Ok(GeneratedField::AckFee),
+                            "timeoutFee" | "timeout_fee" => Ok(GeneratedField::TimeoutFee),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Fee;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.Fee")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Fee, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut recv_fee__ = None;
+                let mut ack_fee__ = None;
+                let mut timeout_fee__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::RecvFee => {
+                            if recv_fee__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("recvFee"));
+                            }
+                            recv_fee__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::AckFee => {
+                            if ack_fee__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("ackFee"));
+                            }
+                            ack_fee__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::TimeoutFee => {
+                            if timeout_fee__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timeoutFee"));
+                            }
+                            timeout_fee__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(Fee {
+                    recv_fee: recv_fee__.unwrap_or_default(),
+                    ack_fee: ack_fee__.unwrap_or_default(),
+                    timeout_fee: timeout_fee__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("ibc.applications.fee.v1.Fee", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for FeeEnabledChannel {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.fee.v1.FeeEnabledChannel", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for FeeEnabledChannel {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["port_id", "portId", "channel_id", "channelId"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = FeeEnabledChannel;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.FeeEnabledChannel")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FeeEnabledChannel, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(FeeEnabledChannel {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.FeeEnabledChannel",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for ForwardRelayerAddress {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.address.is_empty() {
+            len += 1;
+        }
+        if self.packet_id.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.fee.v1.ForwardRelayerAddress", len)?;
+        if !self.address.is_empty() {
+            struct_ser.serialize_field("address", &self.address)?;
+        }
+        if let Some(v) = self.packet_id.as_ref() {
+            struct_ser.serialize_field("packetId", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ForwardRelayerAddress {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["address", "packet_id", "packetId"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Address,
+            PacketId,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "address" => Ok(GeneratedField::Address),
+                            "packetId" | "packet_id" => Ok(GeneratedField::PacketId),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ForwardRelayerAddress;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.ForwardRelayerAddress")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<ForwardRelayerAddress, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut address__ = None;
+                let mut packet_id__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Address => {
+                            if address__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("address"));
+                            }
+                            address__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::PacketId => {
+                            if packet_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("packetId"));
+                            }
+                            packet_id__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(ForwardRelayerAddress {
+                    address: address__.unwrap_or_default(),
+                    packet_id: packet_id__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.ForwardRelayerAddress",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for GenesisState {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.identified_fees.is_empty() {
+            len += 1;
+        }
+        if !self.fee_enabled_channels.is_empty() {
+            len += 1;
+        }
+        if !self.registered_payees.is_empty() {
+            len += 1;
+        }
+        if !self.registered_counterparty_payees.is_empty() {
+            len += 1;
+        }
+        if !self.forward_relayers.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.fee.v1.GenesisState", len)?;
+        if !self.identified_fees.is_empty() {
+            struct_ser.serialize_field("identifiedFees", &self.identified_fees)?;
+        }
+        if !self.fee_enabled_channels.is_empty() {
+            struct_ser.serialize_field("feeEnabledChannels", &self.fee_enabled_channels)?;
+        }
+        if !self.registered_payees.is_empty() {
+            struct_ser.serialize_field("registeredPayees", &self.registered_payees)?;
+        }
+        if !self.registered_counterparty_payees.is_empty() {
+            struct_ser.serialize_field(
+                "registeredCounterpartyPayees",
+                &self.registered_counterparty_payees,
+            )?;
+        }
+        if !self.forward_relayers.is_empty() {
+            struct_ser.serialize_field("forwardRelayers", &self.forward_relayers)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for GenesisState {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "identified_fees",
+            "identifiedFees",
+            "fee_enabled_channels",
+            "feeEnabledChannels",
+            "registered_payees",
+            "registeredPayees",
+            "registered_counterparty_payees",
+            "registeredCounterpartyPayees",
+            "forward_relayers",
+            "forwardRelayers",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            IdentifiedFees,
+            FeeEnabledChannels,
+            RegisteredPayees,
+            RegisteredCounterpartyPayees,
+            ForwardRelayers,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "identifiedFees" | "identified_fees" => {
+                                Ok(GeneratedField::IdentifiedFees)
+                            }
+                            "feeEnabledChannels" | "fee_enabled_channels" => {
+                                Ok(GeneratedField::FeeEnabledChannels)
+                            }
+                            "registeredPayees" | "registered_payees" => {
+                                Ok(GeneratedField::RegisteredPayees)
+                            }
+                            "registeredCounterpartyPayees" | "registered_counterparty_payees" => {
+                                Ok(GeneratedField::RegisteredCounterpartyPayees)
+                            }
+                            "forwardRelayers" | "forward_relayers" => {
+                                Ok(GeneratedField::ForwardRelayers)
+                            }
+                            _ => 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 std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.GenesisState")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GenesisState, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut identified_fees__ = None;
+                let mut fee_enabled_channels__ = None;
+                let mut registered_payees__ = None;
+                let mut registered_counterparty_payees__ = None;
+                let mut forward_relayers__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::IdentifiedFees => {
+                            if identified_fees__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("identifiedFees"));
+                            }
+                            identified_fees__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::FeeEnabledChannels => {
+                            if fee_enabled_channels__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "feeEnabledChannels",
+                                ));
+                            }
+                            fee_enabled_channels__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::RegisteredPayees => {
+                            if registered_payees__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("registeredPayees"));
+                            }
+                            registered_payees__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::RegisteredCounterpartyPayees => {
+                            if registered_counterparty_payees__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "registeredCounterpartyPayees",
+                                ));
+                            }
+                            registered_counterparty_payees__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ForwardRelayers => {
+                            if forward_relayers__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("forwardRelayers"));
+                            }
+                            forward_relayers__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(GenesisState {
+                    identified_fees: identified_fees__.unwrap_or_default(),
+                    fee_enabled_channels: fee_enabled_channels__.unwrap_or_default(),
+                    registered_payees: registered_payees__.unwrap_or_default(),
+                    registered_counterparty_payees: registered_counterparty_payees__
+                        .unwrap_or_default(),
+                    forward_relayers: forward_relayers__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.GenesisState",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for IdentifiedPacketFees {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.packet_id.is_some() {
+            len += 1;
+        }
+        if !self.packet_fees.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.fee.v1.IdentifiedPacketFees", len)?;
+        if let Some(v) = self.packet_id.as_ref() {
+            struct_ser.serialize_field("packetId", v)?;
+        }
+        if !self.packet_fees.is_empty() {
+            struct_ser.serialize_field("packetFees", &self.packet_fees)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for IdentifiedPacketFees {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["packet_id", "packetId", "packet_fees", "packetFees"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PacketId,
+            PacketFees,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "packetId" | "packet_id" => Ok(GeneratedField::PacketId),
+                            "packetFees" | "packet_fees" => Ok(GeneratedField::PacketFees),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = IdentifiedPacketFees;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.IdentifiedPacketFees")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<IdentifiedPacketFees, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut packet_id__ = None;
+                let mut packet_fees__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PacketId => {
+                            if packet_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("packetId"));
+                            }
+                            packet_id__ = map_.next_value()?;
+                        }
+                        GeneratedField::PacketFees => {
+                            if packet_fees__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("packetFees"));
+                            }
+                            packet_fees__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(IdentifiedPacketFees {
+                    packet_id: packet_id__,
+                    packet_fees: packet_fees__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.IdentifiedPacketFees",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for IncentivizedAcknowledgement {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.app_acknowledgement.is_empty() {
+            len += 1;
+        }
+        if !self.forward_relayer_address.is_empty() {
+            len += 1;
+        }
+        if self.underlying_app_success {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.applications.fee.v1.IncentivizedAcknowledgement", len)?;
+        if !self.app_acknowledgement.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "appAcknowledgement",
+                pbjson::private::base64::encode(&self.app_acknowledgement).as_str(),
+            )?;
+        }
+        if !self.forward_relayer_address.is_empty() {
+            struct_ser.serialize_field("forwardRelayerAddress", &self.forward_relayer_address)?;
+        }
+        if self.underlying_app_success {
+            struct_ser.serialize_field("underlyingAppSuccess", &self.underlying_app_success)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for IncentivizedAcknowledgement {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "app_acknowledgement",
+            "appAcknowledgement",
+            "forward_relayer_address",
+            "forwardRelayerAddress",
+            "underlying_app_success",
+            "underlyingAppSuccess",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            AppAcknowledgement,
+            ForwardRelayerAddress,
+            UnderlyingAppSuccess,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "appAcknowledgement" | "app_acknowledgement" => {
+                                Ok(GeneratedField::AppAcknowledgement)
+                            }
+                            "forwardRelayerAddress" | "forward_relayer_address" => {
+                                Ok(GeneratedField::ForwardRelayerAddress)
+                            }
+                            "underlyingAppSuccess" | "underlying_app_success" => {
+                                Ok(GeneratedField::UnderlyingAppSuccess)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = IncentivizedAcknowledgement;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.IncentivizedAcknowledgement")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<IncentivizedAcknowledgement, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut app_acknowledgement__ = None;
+                let mut forward_relayer_address__ = None;
+                let mut underlying_app_success__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::AppAcknowledgement => {
+                            if app_acknowledgement__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "appAcknowledgement",
+                                ));
+                            }
+                            app_acknowledgement__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::ForwardRelayerAddress => {
+                            if forward_relayer_address__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "forwardRelayerAddress",
+                                ));
+                            }
+                            forward_relayer_address__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::UnderlyingAppSuccess => {
+                            if underlying_app_success__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "underlyingAppSuccess",
+                                ));
+                            }
+                            underlying_app_success__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(IncentivizedAcknowledgement {
+                    app_acknowledgement: app_acknowledgement__.unwrap_or_default(),
+                    forward_relayer_address: forward_relayer_address__.unwrap_or_default(),
+                    underlying_app_success: underlying_app_success__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.IncentivizedAcknowledgement",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Metadata {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.fee_version.is_empty() {
+            len += 1;
+        }
+        if !self.app_version.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.fee.v1.Metadata", len)?;
+        if !self.fee_version.is_empty() {
+            struct_ser.serialize_field("feeVersion", &self.fee_version)?;
+        }
+        if !self.app_version.is_empty() {
+            struct_ser.serialize_field("appVersion", &self.app_version)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Metadata {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["fee_version", "feeVersion", "app_version", "appVersion"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            FeeVersion,
+            AppVersion,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "feeVersion" | "fee_version" => Ok(GeneratedField::FeeVersion),
+                            "appVersion" | "app_version" => Ok(GeneratedField::AppVersion),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Metadata;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.Metadata")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Metadata, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut fee_version__ = None;
+                let mut app_version__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::FeeVersion => {
+                            if fee_version__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("feeVersion"));
+                            }
+                            fee_version__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::AppVersion => {
+                            if app_version__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("appVersion"));
+                            }
+                            app_version__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(Metadata {
+                    fee_version: fee_version__.unwrap_or_default(),
+                    app_version: app_version__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.Metadata",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgPayPacketFee {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.fee.is_some() {
+            len += 1;
+        }
+        if !self.source_port_id.is_empty() {
+            len += 1;
+        }
+        if !self.source_channel_id.is_empty() {
+            len += 1;
+        }
+        if !self.signer.is_empty() {
+            len += 1;
+        }
+        if !self.relayers.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.fee.v1.MsgPayPacketFee", len)?;
+        if let Some(v) = self.fee.as_ref() {
+            struct_ser.serialize_field("fee", v)?;
+        }
+        if !self.source_port_id.is_empty() {
+            struct_ser.serialize_field("sourcePortId", &self.source_port_id)?;
+        }
+        if !self.source_channel_id.is_empty() {
+            struct_ser.serialize_field("sourceChannelId", &self.source_channel_id)?;
+        }
+        if !self.signer.is_empty() {
+            struct_ser.serialize_field("signer", &self.signer)?;
+        }
+        if !self.relayers.is_empty() {
+            struct_ser.serialize_field("relayers", &self.relayers)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgPayPacketFee {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "fee",
+            "source_port_id",
+            "sourcePortId",
+            "source_channel_id",
+            "sourceChannelId",
+            "signer",
+            "relayers",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Fee,
+            SourcePortId,
+            SourceChannelId,
+            Signer,
+            Relayers,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "fee" => Ok(GeneratedField::Fee),
+                            "sourcePortId" | "source_port_id" => Ok(GeneratedField::SourcePortId),
+                            "sourceChannelId" | "source_channel_id" => {
+                                Ok(GeneratedField::SourceChannelId)
+                            }
+                            "signer" => Ok(GeneratedField::Signer),
+                            "relayers" => Ok(GeneratedField::Relayers),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgPayPacketFee;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.MsgPayPacketFee")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MsgPayPacketFee, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut fee__ = None;
+                let mut source_port_id__ = None;
+                let mut source_channel_id__ = None;
+                let mut signer__ = None;
+                let mut relayers__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Fee => {
+                            if fee__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("fee"));
+                            }
+                            fee__ = map_.next_value()?;
+                        }
+                        GeneratedField::SourcePortId => {
+                            if source_port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sourcePortId"));
+                            }
+                            source_port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::SourceChannelId => {
+                            if source_channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sourceChannelId"));
+                            }
+                            source_channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Signer => {
+                            if signer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signer"));
+                            }
+                            signer__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Relayers => {
+                            if relayers__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("relayers"));
+                            }
+                            relayers__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgPayPacketFee {
+                    fee: fee__,
+                    source_port_id: source_port_id__.unwrap_or_default(),
+                    source_channel_id: source_channel_id__.unwrap_or_default(),
+                    signer: signer__.unwrap_or_default(),
+                    relayers: relayers__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.MsgPayPacketFee",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgPayPacketFeeAsync {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.packet_id.is_some() {
+            len += 1;
+        }
+        if self.packet_fee.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.fee.v1.MsgPayPacketFeeAsync", len)?;
+        if let Some(v) = self.packet_id.as_ref() {
+            struct_ser.serialize_field("packetId", v)?;
+        }
+        if let Some(v) = self.packet_fee.as_ref() {
+            struct_ser.serialize_field("packetFee", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgPayPacketFeeAsync {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["packet_id", "packetId", "packet_fee", "packetFee"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PacketId,
+            PacketFee,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "packetId" | "packet_id" => Ok(GeneratedField::PacketId),
+                            "packetFee" | "packet_fee" => Ok(GeneratedField::PacketFee),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgPayPacketFeeAsync;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.MsgPayPacketFeeAsync")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgPayPacketFeeAsync, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut packet_id__ = None;
+                let mut packet_fee__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PacketId => {
+                            if packet_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("packetId"));
+                            }
+                            packet_id__ = map_.next_value()?;
+                        }
+                        GeneratedField::PacketFee => {
+                            if packet_fee__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("packetFee"));
+                            }
+                            packet_fee__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(MsgPayPacketFeeAsync {
+                    packet_id: packet_id__,
+                    packet_fee: packet_fee__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.MsgPayPacketFeeAsync",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgPayPacketFeeAsyncResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser = serializer
+            .serialize_struct("ibc.applications.fee.v1.MsgPayPacketFeeAsyncResponse", len)?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgPayPacketFeeAsyncResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgPayPacketFeeAsyncResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.MsgPayPacketFeeAsyncResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgPayPacketFeeAsyncResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(MsgPayPacketFeeAsyncResponse {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.MsgPayPacketFeeAsyncResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgPayPacketFeeResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser =
+            serializer.serialize_struct("ibc.applications.fee.v1.MsgPayPacketFeeResponse", len)?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgPayPacketFeeResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgPayPacketFeeResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.MsgPayPacketFeeResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgPayPacketFeeResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(MsgPayPacketFeeResponse {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.MsgPayPacketFeeResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgRegisterCounterpartyPayee {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if !self.relayer.is_empty() {
+            len += 1;
+        }
+        if !self.counterparty_payee.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.applications.fee.v1.MsgRegisterCounterpartyPayee", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if !self.relayer.is_empty() {
+            struct_ser.serialize_field("relayer", &self.relayer)?;
+        }
+        if !self.counterparty_payee.is_empty() {
+            struct_ser.serialize_field("counterpartyPayee", &self.counterparty_payee)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgRegisterCounterpartyPayee {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "port_id",
+            "portId",
+            "channel_id",
+            "channelId",
+            "relayer",
+            "counterparty_payee",
+            "counterpartyPayee",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+            Relayer,
+            CounterpartyPayee,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "relayer" => Ok(GeneratedField::Relayer),
+                            "counterpartyPayee" | "counterparty_payee" => {
+                                Ok(GeneratedField::CounterpartyPayee)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgRegisterCounterpartyPayee;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.MsgRegisterCounterpartyPayee")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgRegisterCounterpartyPayee, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                let mut relayer__ = None;
+                let mut counterparty_payee__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Relayer => {
+                            if relayer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("relayer"));
+                            }
+                            relayer__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::CounterpartyPayee => {
+                            if counterparty_payee__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("counterpartyPayee"));
+                            }
+                            counterparty_payee__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgRegisterCounterpartyPayee {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                    relayer: relayer__.unwrap_or_default(),
+                    counterparty_payee: counterparty_payee__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.MsgRegisterCounterpartyPayee",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgRegisterCounterpartyPayeeResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser = serializer.serialize_struct(
+            "ibc.applications.fee.v1.MsgRegisterCounterpartyPayeeResponse",
+            len,
+        )?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgRegisterCounterpartyPayeeResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgRegisterCounterpartyPayeeResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str(
+                    "struct ibc.applications.fee.v1.MsgRegisterCounterpartyPayeeResponse",
+                )
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgRegisterCounterpartyPayeeResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(MsgRegisterCounterpartyPayeeResponse {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.MsgRegisterCounterpartyPayeeResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgRegisterPayee {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if !self.relayer.is_empty() {
+            len += 1;
+        }
+        if !self.payee.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.fee.v1.MsgRegisterPayee", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if !self.relayer.is_empty() {
+            struct_ser.serialize_field("relayer", &self.relayer)?;
+        }
+        if !self.payee.is_empty() {
+            struct_ser.serialize_field("payee", &self.payee)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgRegisterPayee {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "port_id",
+            "portId",
+            "channel_id",
+            "channelId",
+            "relayer",
+            "payee",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+            Relayer,
+            Payee,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "relayer" => Ok(GeneratedField::Relayer),
+                            "payee" => Ok(GeneratedField::Payee),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgRegisterPayee;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.MsgRegisterPayee")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MsgRegisterPayee, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                let mut relayer__ = None;
+                let mut payee__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Relayer => {
+                            if relayer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("relayer"));
+                            }
+                            relayer__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Payee => {
+                            if payee__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("payee"));
+                            }
+                            payee__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgRegisterPayee {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                    relayer: relayer__.unwrap_or_default(),
+                    payee: payee__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.MsgRegisterPayee",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgRegisterPayeeResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser =
+            serializer.serialize_struct("ibc.applications.fee.v1.MsgRegisterPayeeResponse", len)?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgRegisterPayeeResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgRegisterPayeeResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.MsgRegisterPayeeResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgRegisterPayeeResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(MsgRegisterPayeeResponse {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.MsgRegisterPayeeResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for PacketFee {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.fee.is_some() {
+            len += 1;
+        }
+        if !self.refund_address.is_empty() {
+            len += 1;
+        }
+        if !self.relayers.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.fee.v1.PacketFee", len)?;
+        if let Some(v) = self.fee.as_ref() {
+            struct_ser.serialize_field("fee", v)?;
+        }
+        if !self.refund_address.is_empty() {
+            struct_ser.serialize_field("refundAddress", &self.refund_address)?;
+        }
+        if !self.relayers.is_empty() {
+            struct_ser.serialize_field("relayers", &self.relayers)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for PacketFee {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["fee", "refund_address", "refundAddress", "relayers"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Fee,
+            RefundAddress,
+            Relayers,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "fee" => Ok(GeneratedField::Fee),
+                            "refundAddress" | "refund_address" => Ok(GeneratedField::RefundAddress),
+                            "relayers" => Ok(GeneratedField::Relayers),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PacketFee;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.PacketFee")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PacketFee, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut fee__ = None;
+                let mut refund_address__ = None;
+                let mut relayers__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Fee => {
+                            if fee__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("fee"));
+                            }
+                            fee__ = map_.next_value()?;
+                        }
+                        GeneratedField::RefundAddress => {
+                            if refund_address__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("refundAddress"));
+                            }
+                            refund_address__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Relayers => {
+                            if relayers__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("relayers"));
+                            }
+                            relayers__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(PacketFee {
+                    fee: fee__,
+                    refund_address: refund_address__.unwrap_or_default(),
+                    relayers: relayers__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.PacketFee",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for PacketFees {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.packet_fees.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.fee.v1.PacketFees", len)?;
+        if !self.packet_fees.is_empty() {
+            struct_ser.serialize_field("packetFees", &self.packet_fees)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for PacketFees {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["packet_fees", "packetFees"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PacketFees,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "packetFees" | "packet_fees" => Ok(GeneratedField::PacketFees),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PacketFees;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.PacketFees")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PacketFees, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut packet_fees__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PacketFees => {
+                            if packet_fees__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("packetFees"));
+                            }
+                            packet_fees__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(PacketFees {
+                    packet_fees: packet_fees__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.PacketFees",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryCounterpartyPayeeRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if !self.relayer.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.applications.fee.v1.QueryCounterpartyPayeeRequest", len)?;
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if !self.relayer.is_empty() {
+            struct_ser.serialize_field("relayer", &self.relayer)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryCounterpartyPayeeRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["channel_id", "channelId", "relayer"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ChannelId,
+            Relayer,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "relayer" => Ok(GeneratedField::Relayer),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryCounterpartyPayeeRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.QueryCounterpartyPayeeRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryCounterpartyPayeeRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut channel_id__ = None;
+                let mut relayer__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Relayer => {
+                            if relayer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("relayer"));
+                            }
+                            relayer__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryCounterpartyPayeeRequest {
+                    channel_id: channel_id__.unwrap_or_default(),
+                    relayer: relayer__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.QueryCounterpartyPayeeRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryCounterpartyPayeeResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.counterparty_payee.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.fee.v1.QueryCounterpartyPayeeResponse",
+            len,
+        )?;
+        if !self.counterparty_payee.is_empty() {
+            struct_ser.serialize_field("counterpartyPayee", &self.counterparty_payee)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryCounterpartyPayeeResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["counterparty_payee", "counterpartyPayee"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            CounterpartyPayee,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "counterpartyPayee" | "counterparty_payee" => {
+                                Ok(GeneratedField::CounterpartyPayee)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryCounterpartyPayeeResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.QueryCounterpartyPayeeResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryCounterpartyPayeeResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut counterparty_payee__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::CounterpartyPayee => {
+                            if counterparty_payee__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("counterpartyPayee"));
+                            }
+                            counterparty_payee__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryCounterpartyPayeeResponse {
+                    counterparty_payee: counterparty_payee__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.QueryCounterpartyPayeeResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryFeeEnabledChannelRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.applications.fee.v1.QueryFeeEnabledChannelRequest", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryFeeEnabledChannelRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["port_id", "portId", "channel_id", "channelId"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryFeeEnabledChannelRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.QueryFeeEnabledChannelRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryFeeEnabledChannelRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryFeeEnabledChannelRequest {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.QueryFeeEnabledChannelRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryFeeEnabledChannelResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.fee_enabled {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.fee.v1.QueryFeeEnabledChannelResponse",
+            len,
+        )?;
+        if self.fee_enabled {
+            struct_ser.serialize_field("feeEnabled", &self.fee_enabled)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryFeeEnabledChannelResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["fee_enabled", "feeEnabled"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            FeeEnabled,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "feeEnabled" | "fee_enabled" => Ok(GeneratedField::FeeEnabled),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryFeeEnabledChannelResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.QueryFeeEnabledChannelResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryFeeEnabledChannelResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut fee_enabled__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::FeeEnabled => {
+                            if fee_enabled__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("feeEnabled"));
+                            }
+                            fee_enabled__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryFeeEnabledChannelResponse {
+                    fee_enabled: fee_enabled__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.QueryFeeEnabledChannelResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryFeeEnabledChannelsRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.pagination.is_some() {
+            len += 1;
+        }
+        if self.query_height != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.fee.v1.QueryFeeEnabledChannelsRequest",
+            len,
+        )?;
+        if let Some(v) = self.pagination.as_ref() {
+            struct_ser.serialize_field("pagination", v)?;
+        }
+        if self.query_height != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "queryHeight",
+                ToString::to_string(&self.query_height).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryFeeEnabledChannelsRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["pagination", "query_height", "queryHeight"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Pagination,
+            QueryHeight,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "pagination" => Ok(GeneratedField::Pagination),
+                            "queryHeight" | "query_height" => Ok(GeneratedField::QueryHeight),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryFeeEnabledChannelsRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.QueryFeeEnabledChannelsRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryFeeEnabledChannelsRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut pagination__ = None;
+                let mut query_height__ = 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()?;
+                        }
+                        GeneratedField::QueryHeight => {
+                            if query_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("queryHeight"));
+                            }
+                            query_height__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(QueryFeeEnabledChannelsRequest {
+                    pagination: pagination__,
+                    query_height: query_height__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.QueryFeeEnabledChannelsRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryFeeEnabledChannelsResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.fee_enabled_channels.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.fee.v1.QueryFeeEnabledChannelsResponse",
+            len,
+        )?;
+        if !self.fee_enabled_channels.is_empty() {
+            struct_ser.serialize_field("feeEnabledChannels", &self.fee_enabled_channels)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryFeeEnabledChannelsResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["fee_enabled_channels", "feeEnabledChannels"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            FeeEnabledChannels,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "feeEnabledChannels" | "fee_enabled_channels" => {
+                                Ok(GeneratedField::FeeEnabledChannels)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryFeeEnabledChannelsResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter
+                    .write_str("struct ibc.applications.fee.v1.QueryFeeEnabledChannelsResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryFeeEnabledChannelsResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut fee_enabled_channels__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::FeeEnabledChannels => {
+                            if fee_enabled_channels__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "feeEnabledChannels",
+                                ));
+                            }
+                            fee_enabled_channels__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryFeeEnabledChannelsResponse {
+                    fee_enabled_channels: fee_enabled_channels__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.QueryFeeEnabledChannelsResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryIncentivizedPacketRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.packet_id.is_some() {
+            len += 1;
+        }
+        if self.query_height != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.fee.v1.QueryIncentivizedPacketRequest",
+            len,
+        )?;
+        if let Some(v) = self.packet_id.as_ref() {
+            struct_ser.serialize_field("packetId", v)?;
+        }
+        if self.query_height != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "queryHeight",
+                ToString::to_string(&self.query_height).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryIncentivizedPacketRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["packet_id", "packetId", "query_height", "queryHeight"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PacketId,
+            QueryHeight,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "packetId" | "packet_id" => Ok(GeneratedField::PacketId),
+                            "queryHeight" | "query_height" => Ok(GeneratedField::QueryHeight),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryIncentivizedPacketRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.QueryIncentivizedPacketRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryIncentivizedPacketRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut packet_id__ = None;
+                let mut query_height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PacketId => {
+                            if packet_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("packetId"));
+                            }
+                            packet_id__ = map_.next_value()?;
+                        }
+                        GeneratedField::QueryHeight => {
+                            if query_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("queryHeight"));
+                            }
+                            query_height__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(QueryIncentivizedPacketRequest {
+                    packet_id: packet_id__,
+                    query_height: query_height__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.QueryIncentivizedPacketRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryIncentivizedPacketResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.incentivized_packet.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.fee.v1.QueryIncentivizedPacketResponse",
+            len,
+        )?;
+        if let Some(v) = self.incentivized_packet.as_ref() {
+            struct_ser.serialize_field("incentivizedPacket", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryIncentivizedPacketResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["incentivized_packet", "incentivizedPacket"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            IncentivizedPacket,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "incentivizedPacket" | "incentivized_packet" => {
+                                Ok(GeneratedField::IncentivizedPacket)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryIncentivizedPacketResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter
+                    .write_str("struct ibc.applications.fee.v1.QueryIncentivizedPacketResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryIncentivizedPacketResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut incentivized_packet__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::IncentivizedPacket => {
+                            if incentivized_packet__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "incentivizedPacket",
+                                ));
+                            }
+                            incentivized_packet__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryIncentivizedPacketResponse {
+                    incentivized_packet: incentivized_packet__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.QueryIncentivizedPacketResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryIncentivizedPacketsForChannelRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.pagination.is_some() {
+            len += 1;
+        }
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if self.query_height != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.fee.v1.QueryIncentivizedPacketsForChannelRequest",
+            len,
+        )?;
+        if let Some(v) = self.pagination.as_ref() {
+            struct_ser.serialize_field("pagination", v)?;
+        }
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if self.query_height != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "queryHeight",
+                ToString::to_string(&self.query_height).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryIncentivizedPacketsForChannelRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "pagination",
+            "port_id",
+            "portId",
+            "channel_id",
+            "channelId",
+            "query_height",
+            "queryHeight",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Pagination,
+            PortId,
+            ChannelId,
+            QueryHeight,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "pagination" => Ok(GeneratedField::Pagination),
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "queryHeight" | "query_height" => Ok(GeneratedField::QueryHeight),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryIncentivizedPacketsForChannelRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str(
+                    "struct ibc.applications.fee.v1.QueryIncentivizedPacketsForChannelRequest",
+                )
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryIncentivizedPacketsForChannelRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut pagination__ = None;
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                let mut query_height__ = 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()?;
+                        }
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::QueryHeight => {
+                            if query_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("queryHeight"));
+                            }
+                            query_height__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(QueryIncentivizedPacketsForChannelRequest {
+                    pagination: pagination__,
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                    query_height: query_height__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.QueryIncentivizedPacketsForChannelRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryIncentivizedPacketsForChannelResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.incentivized_packets.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.fee.v1.QueryIncentivizedPacketsForChannelResponse",
+            len,
+        )?;
+        if !self.incentivized_packets.is_empty() {
+            struct_ser.serialize_field("incentivizedPackets", &self.incentivized_packets)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryIncentivizedPacketsForChannelResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["incentivized_packets", "incentivizedPackets"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            IncentivizedPackets,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "incentivizedPackets" | "incentivized_packets" => {
+                                Ok(GeneratedField::IncentivizedPackets)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryIncentivizedPacketsForChannelResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str(
+                    "struct ibc.applications.fee.v1.QueryIncentivizedPacketsForChannelResponse",
+                )
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryIncentivizedPacketsForChannelResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut incentivized_packets__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::IncentivizedPackets => {
+                            if incentivized_packets__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "incentivizedPackets",
+                                ));
+                            }
+                            incentivized_packets__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryIncentivizedPacketsForChannelResponse {
+                    incentivized_packets: incentivized_packets__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.QueryIncentivizedPacketsForChannelResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryIncentivizedPacketsRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.pagination.is_some() {
+            len += 1;
+        }
+        if self.query_height != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.fee.v1.QueryIncentivizedPacketsRequest",
+            len,
+        )?;
+        if let Some(v) = self.pagination.as_ref() {
+            struct_ser.serialize_field("pagination", v)?;
+        }
+        if self.query_height != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "queryHeight",
+                ToString::to_string(&self.query_height).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryIncentivizedPacketsRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["pagination", "query_height", "queryHeight"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Pagination,
+            QueryHeight,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "pagination" => Ok(GeneratedField::Pagination),
+                            "queryHeight" | "query_height" => Ok(GeneratedField::QueryHeight),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryIncentivizedPacketsRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter
+                    .write_str("struct ibc.applications.fee.v1.QueryIncentivizedPacketsRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryIncentivizedPacketsRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut pagination__ = None;
+                let mut query_height__ = 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()?;
+                        }
+                        GeneratedField::QueryHeight => {
+                            if query_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("queryHeight"));
+                            }
+                            query_height__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(QueryIncentivizedPacketsRequest {
+                    pagination: pagination__,
+                    query_height: query_height__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.QueryIncentivizedPacketsRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryIncentivizedPacketsResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.incentivized_packets.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.fee.v1.QueryIncentivizedPacketsResponse",
+            len,
+        )?;
+        if !self.incentivized_packets.is_empty() {
+            struct_ser.serialize_field("incentivizedPackets", &self.incentivized_packets)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryIncentivizedPacketsResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["incentivized_packets", "incentivizedPackets"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            IncentivizedPackets,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "incentivizedPackets" | "incentivized_packets" => {
+                                Ok(GeneratedField::IncentivizedPackets)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryIncentivizedPacketsResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter
+                    .write_str("struct ibc.applications.fee.v1.QueryIncentivizedPacketsResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryIncentivizedPacketsResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut incentivized_packets__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::IncentivizedPackets => {
+                            if incentivized_packets__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "incentivizedPackets",
+                                ));
+                            }
+                            incentivized_packets__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryIncentivizedPacketsResponse {
+                    incentivized_packets: incentivized_packets__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.QueryIncentivizedPacketsResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryPayeeRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if !self.relayer.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.fee.v1.QueryPayeeRequest", len)?;
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if !self.relayer.is_empty() {
+            struct_ser.serialize_field("relayer", &self.relayer)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryPayeeRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["channel_id", "channelId", "relayer"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ChannelId,
+            Relayer,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "relayer" => Ok(GeneratedField::Relayer),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryPayeeRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.QueryPayeeRequest")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<QueryPayeeRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut channel_id__ = None;
+                let mut relayer__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Relayer => {
+                            if relayer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("relayer"));
+                            }
+                            relayer__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryPayeeRequest {
+                    channel_id: channel_id__.unwrap_or_default(),
+                    relayer: relayer__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.QueryPayeeRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryPayeeResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.payee_address.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.fee.v1.QueryPayeeResponse", len)?;
+        if !self.payee_address.is_empty() {
+            struct_ser.serialize_field("payeeAddress", &self.payee_address)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryPayeeResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["payee_address", "payeeAddress"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PayeeAddress,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "payeeAddress" | "payee_address" => Ok(GeneratedField::PayeeAddress),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryPayeeResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.QueryPayeeResponse")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<QueryPayeeResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut payee_address__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PayeeAddress => {
+                            if payee_address__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("payeeAddress"));
+                            }
+                            payee_address__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryPayeeResponse {
+                    payee_address: payee_address__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.QueryPayeeResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryTotalAckFeesRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.packet_id.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.fee.v1.QueryTotalAckFeesRequest", len)?;
+        if let Some(v) = self.packet_id.as_ref() {
+            struct_ser.serialize_field("packetId", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryTotalAckFeesRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["packet_id", "packetId"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PacketId,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "packetId" | "packet_id" => Ok(GeneratedField::PacketId),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryTotalAckFeesRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.QueryTotalAckFeesRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryTotalAckFeesRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut packet_id__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PacketId => {
+                            if packet_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("packetId"));
+                            }
+                            packet_id__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryTotalAckFeesRequest {
+                    packet_id: packet_id__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.QueryTotalAckFeesRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryTotalAckFeesResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.ack_fees.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.applications.fee.v1.QueryTotalAckFeesResponse", len)?;
+        if !self.ack_fees.is_empty() {
+            struct_ser.serialize_field("ackFees", &self.ack_fees)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryTotalAckFeesResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["ack_fees", "ackFees"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            AckFees,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "ackFees" | "ack_fees" => Ok(GeneratedField::AckFees),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryTotalAckFeesResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.QueryTotalAckFeesResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryTotalAckFeesResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut ack_fees__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::AckFees => {
+                            if ack_fees__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("ackFees"));
+                            }
+                            ack_fees__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryTotalAckFeesResponse {
+                    ack_fees: ack_fees__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.QueryTotalAckFeesResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryTotalRecvFeesRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.packet_id.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.applications.fee.v1.QueryTotalRecvFeesRequest", len)?;
+        if let Some(v) = self.packet_id.as_ref() {
+            struct_ser.serialize_field("packetId", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryTotalRecvFeesRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["packet_id", "packetId"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PacketId,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "packetId" | "packet_id" => Ok(GeneratedField::PacketId),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryTotalRecvFeesRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.QueryTotalRecvFeesRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryTotalRecvFeesRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut packet_id__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PacketId => {
+                            if packet_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("packetId"));
+                            }
+                            packet_id__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryTotalRecvFeesRequest {
+                    packet_id: packet_id__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.QueryTotalRecvFeesRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryTotalRecvFeesResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.recv_fees.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.applications.fee.v1.QueryTotalRecvFeesResponse", len)?;
+        if !self.recv_fees.is_empty() {
+            struct_ser.serialize_field("recvFees", &self.recv_fees)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryTotalRecvFeesResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["recv_fees", "recvFees"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            RecvFees,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "recvFees" | "recv_fees" => Ok(GeneratedField::RecvFees),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryTotalRecvFeesResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.QueryTotalRecvFeesResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryTotalRecvFeesResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut recv_fees__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::RecvFees => {
+                            if recv_fees__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("recvFees"));
+                            }
+                            recv_fees__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryTotalRecvFeesResponse {
+                    recv_fees: recv_fees__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.QueryTotalRecvFeesResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryTotalTimeoutFeesRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.packet_id.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.applications.fee.v1.QueryTotalTimeoutFeesRequest", len)?;
+        if let Some(v) = self.packet_id.as_ref() {
+            struct_ser.serialize_field("packetId", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryTotalTimeoutFeesRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["packet_id", "packetId"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PacketId,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "packetId" | "packet_id" => Ok(GeneratedField::PacketId),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryTotalTimeoutFeesRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.QueryTotalTimeoutFeesRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryTotalTimeoutFeesRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut packet_id__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PacketId => {
+                            if packet_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("packetId"));
+                            }
+                            packet_id__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryTotalTimeoutFeesRequest {
+                    packet_id: packet_id__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.QueryTotalTimeoutFeesRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryTotalTimeoutFeesResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.timeout_fees.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.applications.fee.v1.QueryTotalTimeoutFeesResponse", len)?;
+        if !self.timeout_fees.is_empty() {
+            struct_ser.serialize_field("timeoutFees", &self.timeout_fees)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryTotalTimeoutFeesResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["timeout_fees", "timeoutFees"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            TimeoutFees,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "timeoutFees" | "timeout_fees" => Ok(GeneratedField::TimeoutFees),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryTotalTimeoutFeesResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.QueryTotalTimeoutFeesResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryTotalTimeoutFeesResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut timeout_fees__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::TimeoutFees => {
+                            if timeout_fees__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timeoutFees"));
+                            }
+                            timeout_fees__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryTotalTimeoutFeesResponse {
+                    timeout_fees: timeout_fees__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.QueryTotalTimeoutFeesResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for RegisteredCounterpartyPayee {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if !self.relayer.is_empty() {
+            len += 1;
+        }
+        if !self.counterparty_payee.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.applications.fee.v1.RegisteredCounterpartyPayee", len)?;
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if !self.relayer.is_empty() {
+            struct_ser.serialize_field("relayer", &self.relayer)?;
+        }
+        if !self.counterparty_payee.is_empty() {
+            struct_ser.serialize_field("counterpartyPayee", &self.counterparty_payee)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for RegisteredCounterpartyPayee {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "channel_id",
+            "channelId",
+            "relayer",
+            "counterparty_payee",
+            "counterpartyPayee",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ChannelId,
+            Relayer,
+            CounterpartyPayee,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "relayer" => Ok(GeneratedField::Relayer),
+                            "counterpartyPayee" | "counterparty_payee" => {
+                                Ok(GeneratedField::CounterpartyPayee)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = RegisteredCounterpartyPayee;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.RegisteredCounterpartyPayee")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<RegisteredCounterpartyPayee, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut channel_id__ = None;
+                let mut relayer__ = None;
+                let mut counterparty_payee__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Relayer => {
+                            if relayer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("relayer"));
+                            }
+                            relayer__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::CounterpartyPayee => {
+                            if counterparty_payee__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("counterpartyPayee"));
+                            }
+                            counterparty_payee__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(RegisteredCounterpartyPayee {
+                    channel_id: channel_id__.unwrap_or_default(),
+                    relayer: relayer__.unwrap_or_default(),
+                    counterparty_payee: counterparty_payee__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.RegisteredCounterpartyPayee",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for RegisteredPayee {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if !self.relayer.is_empty() {
+            len += 1;
+        }
+        if !self.payee.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.fee.v1.RegisteredPayee", len)?;
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if !self.relayer.is_empty() {
+            struct_ser.serialize_field("relayer", &self.relayer)?;
+        }
+        if !self.payee.is_empty() {
+            struct_ser.serialize_field("payee", &self.payee)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for RegisteredPayee {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["channel_id", "channelId", "relayer", "payee"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ChannelId,
+            Relayer,
+            Payee,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "relayer" => Ok(GeneratedField::Relayer),
+                            "payee" => Ok(GeneratedField::Payee),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = RegisteredPayee;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.fee.v1.RegisteredPayee")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RegisteredPayee, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut channel_id__ = None;
+                let mut relayer__ = None;
+                let mut payee__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Relayer => {
+                            if relayer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("relayer"));
+                            }
+                            relayer__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Payee => {
+                            if payee__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("payee"));
+                            }
+                            payee__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(RegisteredPayee {
+                    channel_id: channel_id__.unwrap_or_default(),
+                    relayer: relayer__.unwrap_or_default(),
+                    payee: payee__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.fee.v1.RegisteredPayee",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.fee.v1.tonic.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.fee.v1.tonic.rs
new file mode 100644
index 00000000..484ce27a
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.fee.v1.tonic.rs
@@ -0,0 +1,1370 @@
+// @generated
+/// Generated client implementations.
+#[cfg(feature = "grpc")]
+pub mod query_client {
+    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
+    use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
+    #[derive(Debug, Clone)]
+    pub struct QueryClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    #[cfg(feature = "grpc-transport")]
+    impl QueryClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> QueryClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> QueryClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
+                Into<StdError> + Send + Sync,
+        {
+            QueryClient::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
+        }
+        pub async fn incentivized_packets(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryIncentivizedPacketsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryIncentivizedPacketsResponse>,
+            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.fee.v1.Query/IncentivizedPackets",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.applications.fee.v1.Query",
+                "IncentivizedPackets",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn incentivized_packet(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryIncentivizedPacketRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryIncentivizedPacketResponse>,
+            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.fee.v1.Query/IncentivizedPacket",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.applications.fee.v1.Query",
+                "IncentivizedPacket",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn incentivized_packets_for_channel(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryIncentivizedPacketsForChannelRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryIncentivizedPacketsForChannelResponse>,
+            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.fee.v1.Query/IncentivizedPacketsForChannel",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.applications.fee.v1.Query",
+                "IncentivizedPacketsForChannel",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn total_recv_fees(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryTotalRecvFeesRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryTotalRecvFeesResponse>, 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.fee.v1.Query/TotalRecvFees",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.applications.fee.v1.Query",
+                "TotalRecvFees",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn total_ack_fees(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryTotalAckFeesRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryTotalAckFeesResponse>, 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.fee.v1.Query/TotalAckFees");
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.applications.fee.v1.Query",
+                "TotalAckFees",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn total_timeout_fees(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryTotalTimeoutFeesRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryTotalTimeoutFeesResponse>, 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.fee.v1.Query/TotalTimeoutFees",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.applications.fee.v1.Query",
+                "TotalTimeoutFees",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn payee(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryPayeeRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryPayeeResponse>, 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.fee.v1.Query/Payee");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("ibc.applications.fee.v1.Query", "Payee"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn counterparty_payee(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryCounterpartyPayeeRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryCounterpartyPayeeResponse>,
+            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.fee.v1.Query/CounterpartyPayee",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.applications.fee.v1.Query",
+                "CounterpartyPayee",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn fee_enabled_channels(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryFeeEnabledChannelsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryFeeEnabledChannelsResponse>,
+            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.fee.v1.Query/FeeEnabledChannels",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.applications.fee.v1.Query",
+                "FeeEnabledChannels",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn fee_enabled_channel(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryFeeEnabledChannelRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryFeeEnabledChannelResponse>,
+            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.fee.v1.Query/FeeEnabledChannel",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.applications.fee.v1.Query",
+                "FeeEnabledChannel",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+#[cfg(feature = "grpc")]
+pub mod query_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 QueryServer.
+    #[async_trait]
+    pub trait Query: Send + Sync + 'static {
+        async fn incentivized_packets(
+            &self,
+            request: tonic::Request<super::QueryIncentivizedPacketsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryIncentivizedPacketsResponse>,
+            tonic::Status,
+        >;
+        async fn incentivized_packet(
+            &self,
+            request: tonic::Request<super::QueryIncentivizedPacketRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryIncentivizedPacketResponse>,
+            tonic::Status,
+        >;
+        async fn incentivized_packets_for_channel(
+            &self,
+            request: tonic::Request<super::QueryIncentivizedPacketsForChannelRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryIncentivizedPacketsForChannelResponse>,
+            tonic::Status,
+        >;
+        async fn total_recv_fees(
+            &self,
+            request: tonic::Request<super::QueryTotalRecvFeesRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryTotalRecvFeesResponse>, tonic::Status>;
+        async fn total_ack_fees(
+            &self,
+            request: tonic::Request<super::QueryTotalAckFeesRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryTotalAckFeesResponse>, tonic::Status>;
+        async fn total_timeout_fees(
+            &self,
+            request: tonic::Request<super::QueryTotalTimeoutFeesRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryTotalTimeoutFeesResponse>, tonic::Status>;
+        async fn payee(
+            &self,
+            request: tonic::Request<super::QueryPayeeRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryPayeeResponse>, tonic::Status>;
+        async fn counterparty_payee(
+            &self,
+            request: tonic::Request<super::QueryCounterpartyPayeeRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryCounterpartyPayeeResponse>,
+            tonic::Status,
+        >;
+        async fn fee_enabled_channels(
+            &self,
+            request: tonic::Request<super::QueryFeeEnabledChannelsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryFeeEnabledChannelsResponse>,
+            tonic::Status,
+        >;
+        async fn fee_enabled_channel(
+            &self,
+            request: tonic::Request<super::QueryFeeEnabledChannelRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryFeeEnabledChannelResponse>,
+            tonic::Status,
+        >;
+    }
+    #[derive(Debug)]
+    pub struct QueryServer<T: Query> {
+        inner: _Inner<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    struct _Inner<T>(Arc<T>);
+    impl<T: Query> QueryServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            let inner = _Inner(inner);
+            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<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
+        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<T, B> tonic::codegen::Service<http::Request<B>> for QueryServer<T>
+    where
+        T: Query,
+        B: Body + Send + 'static,
+        B::Error: Into<StdError> + Send + 'static,
+    {
+        type Response = http::Response<tonic::body::BoxBody>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            let inner = self.inner.clone();
+            match req.uri().path() {
+                "/ibc.applications.fee.v1.Query/IncentivizedPackets" => {
+                    #[allow(non_camel_case_types)]
+                    struct IncentivizedPacketsSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query>
+                        tonic::server::UnaryService<super::QueryIncentivizedPacketsRequest>
+                        for IncentivizedPacketsSvc<T>
+                    {
+                        type Response = super::QueryIncentivizedPacketsResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryIncentivizedPacketsRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).incentivized_packets(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 = IncentivizedPacketsSvc(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.fee.v1.Query/IncentivizedPacket" => {
+                    #[allow(non_camel_case_types)]
+                    struct IncentivizedPacketSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query>
+                        tonic::server::UnaryService<super::QueryIncentivizedPacketRequest>
+                        for IncentivizedPacketSvc<T>
+                    {
+                        type Response = super::QueryIncentivizedPacketResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryIncentivizedPacketRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).incentivized_packet(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 = IncentivizedPacketSvc(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.fee.v1.Query/IncentivizedPacketsForChannel" => {
+                    #[allow(non_camel_case_types)]
+                    struct IncentivizedPacketsForChannelSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query>
+                        tonic::server::UnaryService<
+                            super::QueryIncentivizedPacketsForChannelRequest,
+                        > for IncentivizedPacketsForChannelSvc<T>
+                    {
+                        type Response = super::QueryIncentivizedPacketsForChannelResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<
+                                super::QueryIncentivizedPacketsForChannelRequest,
+                            >,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                (*inner).incentivized_packets_for_channel(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 = IncentivizedPacketsForChannelSvc(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.fee.v1.Query/TotalRecvFees" => {
+                    #[allow(non_camel_case_types)]
+                    struct TotalRecvFeesSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryTotalRecvFeesRequest>
+                        for TotalRecvFeesSvc<T>
+                    {
+                        type Response = super::QueryTotalRecvFeesResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryTotalRecvFeesRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).total_recv_fees(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 = TotalRecvFeesSvc(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.fee.v1.Query/TotalAckFees" => {
+                    #[allow(non_camel_case_types)]
+                    struct TotalAckFeesSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryTotalAckFeesRequest> for TotalAckFeesSvc<T> {
+                        type Response = super::QueryTotalAckFeesResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryTotalAckFeesRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).total_ack_fees(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 = TotalAckFeesSvc(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.fee.v1.Query/TotalTimeoutFees" => {
+                    #[allow(non_camel_case_types)]
+                    struct TotalTimeoutFeesSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryTotalTimeoutFeesRequest>
+                        for TotalTimeoutFeesSvc<T>
+                    {
+                        type Response = super::QueryTotalTimeoutFeesResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryTotalTimeoutFeesRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).total_timeout_fees(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 = TotalTimeoutFeesSvc(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.fee.v1.Query/Payee" => {
+                    #[allow(non_camel_case_types)]
+                    struct PayeeSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryPayeeRequest> for PayeeSvc<T> {
+                        type Response = super::QueryPayeeResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryPayeeRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).payee(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 = PayeeSvc(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.fee.v1.Query/CounterpartyPayee" => {
+                    #[allow(non_camel_case_types)]
+                    struct CounterpartyPayeeSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryCounterpartyPayeeRequest>
+                        for CounterpartyPayeeSvc<T>
+                    {
+                        type Response = super::QueryCounterpartyPayeeResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryCounterpartyPayeeRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).counterparty_payee(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 = CounterpartyPayeeSvc(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.fee.v1.Query/FeeEnabledChannels" => {
+                    #[allow(non_camel_case_types)]
+                    struct FeeEnabledChannelsSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query>
+                        tonic::server::UnaryService<super::QueryFeeEnabledChannelsRequest>
+                        for FeeEnabledChannelsSvc<T>
+                    {
+                        type Response = super::QueryFeeEnabledChannelsResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryFeeEnabledChannelsRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).fee_enabled_channels(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 = FeeEnabledChannelsSvc(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.fee.v1.Query/FeeEnabledChannel" => {
+                    #[allow(non_camel_case_types)]
+                    struct FeeEnabledChannelSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryFeeEnabledChannelRequest>
+                        for FeeEnabledChannelSvc<T>
+                    {
+                        type Response = super::QueryFeeEnabledChannelResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryFeeEnabledChannelRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).fee_enabled_channel(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 = FeeEnabledChannelSvc(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", "12")
+                        .header("content-type", "application/grpc")
+                        .body(empty_body())
+                        .unwrap())
+                }),
+            }
+        }
+    }
+    impl<T: Query> Clone for QueryServer<T> {
+        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<T: Query> Clone for _Inner<T> {
+        fn clone(&self) -> Self {
+            Self(Arc::clone(&self.0))
+        }
+    }
+    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "{:?}", self.0)
+        }
+    }
+    impl<T: Query> tonic::server::NamedService for QueryServer<T> {
+        const NAME: &'static str = "ibc.applications.fee.v1.Query";
+    }
+}
+/// Generated client implementations.
+#[cfg(feature = "grpc")]
+pub mod msg_client {
+    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
+    use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
+    #[derive(Debug, Clone)]
+    pub struct MsgClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    #[cfg(feature = "grpc-transport")]
+    impl MsgClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> MsgClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(inner: T, interceptor: F) -> MsgClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
+                Into<StdError> + Send + Sync,
+        {
+            MsgClient::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
+        }
+        pub async fn register_payee(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgRegisterPayee>,
+        ) -> std::result::Result<tonic::Response<super::MsgRegisterPayeeResponse>, 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.fee.v1.Msg/RegisterPayee");
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.applications.fee.v1.Msg",
+                "RegisterPayee",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn register_counterparty_payee(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgRegisterCounterpartyPayee>,
+        ) -> std::result::Result<
+            tonic::Response<super::MsgRegisterCounterpartyPayeeResponse>,
+            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.fee.v1.Msg/RegisterCounterpartyPayee",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.applications.fee.v1.Msg",
+                "RegisterCounterpartyPayee",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn pay_packet_fee(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgPayPacketFee>,
+        ) -> std::result::Result<tonic::Response<super::MsgPayPacketFeeResponse>, 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.fee.v1.Msg/PayPacketFee");
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.applications.fee.v1.Msg",
+                "PayPacketFee",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn pay_packet_fee_async(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgPayPacketFeeAsync>,
+        ) -> std::result::Result<tonic::Response<super::MsgPayPacketFeeAsyncResponse>, 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.fee.v1.Msg/PayPacketFeeAsync",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.applications.fee.v1.Msg",
+                "PayPacketFeeAsync",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+#[cfg(feature = "grpc")]
+pub mod msg_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 MsgServer.
+    #[async_trait]
+    pub trait Msg: Send + Sync + 'static {
+        async fn register_payee(
+            &self,
+            request: tonic::Request<super::MsgRegisterPayee>,
+        ) -> std::result::Result<tonic::Response<super::MsgRegisterPayeeResponse>, tonic::Status>;
+        async fn register_counterparty_payee(
+            &self,
+            request: tonic::Request<super::MsgRegisterCounterpartyPayee>,
+        ) -> std::result::Result<
+            tonic::Response<super::MsgRegisterCounterpartyPayeeResponse>,
+            tonic::Status,
+        >;
+        async fn pay_packet_fee(
+            &self,
+            request: tonic::Request<super::MsgPayPacketFee>,
+        ) -> std::result::Result<tonic::Response<super::MsgPayPacketFeeResponse>, tonic::Status>;
+        async fn pay_packet_fee_async(
+            &self,
+            request: tonic::Request<super::MsgPayPacketFeeAsync>,
+        ) -> std::result::Result<tonic::Response<super::MsgPayPacketFeeAsyncResponse>, tonic::Status>;
+    }
+    #[derive(Debug)]
+    pub struct MsgServer<T: Msg> {
+        inner: _Inner<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    struct _Inner<T>(Arc<T>);
+    impl<T: Msg> MsgServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            let inner = _Inner(inner);
+            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<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
+        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<T, B> tonic::codegen::Service<http::Request<B>> for MsgServer<T>
+    where
+        T: Msg,
+        B: Body + Send + 'static,
+        B::Error: Into<StdError> + Send + 'static,
+    {
+        type Response = http::Response<tonic::body::BoxBody>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            let inner = self.inner.clone();
+            match req.uri().path() {
+                "/ibc.applications.fee.v1.Msg/RegisterPayee" => {
+                    #[allow(non_camel_case_types)]
+                    struct RegisterPayeeSvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgRegisterPayee> for RegisterPayeeSvc<T> {
+                        type Response = super::MsgRegisterPayeeResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgRegisterPayee>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).register_payee(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 = RegisterPayeeSvc(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.fee.v1.Msg/RegisterCounterpartyPayee" => {
+                    #[allow(non_camel_case_types)]
+                    struct RegisterCounterpartyPayeeSvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgRegisterCounterpartyPayee>
+                        for RegisterCounterpartyPayeeSvc<T>
+                    {
+                        type Response = super::MsgRegisterCounterpartyPayeeResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgRegisterCounterpartyPayee>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut =
+                                async move { (*inner).register_counterparty_payee(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 = RegisterCounterpartyPayeeSvc(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.fee.v1.Msg/PayPacketFee" => {
+                    #[allow(non_camel_case_types)]
+                    struct PayPacketFeeSvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgPayPacketFee> for PayPacketFeeSvc<T> {
+                        type Response = super::MsgPayPacketFeeResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgPayPacketFee>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).pay_packet_fee(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 = PayPacketFeeSvc(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.fee.v1.Msg/PayPacketFeeAsync" => {
+                    #[allow(non_camel_case_types)]
+                    struct PayPacketFeeAsyncSvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgPayPacketFeeAsync> for PayPacketFeeAsyncSvc<T> {
+                        type Response = super::MsgPayPacketFeeAsyncResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgPayPacketFeeAsync>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).pay_packet_fee_async(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 = PayPacketFeeAsyncSvc(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", "12")
+                        .header("content-type", "application/grpc")
+                        .body(empty_body())
+                        .unwrap())
+                }),
+            }
+        }
+    }
+    impl<T: Msg> Clone for MsgServer<T> {
+        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<T: Msg> Clone for _Inner<T> {
+        fn clone(&self) -> Self {
+            Self(Arc::clone(&self.0))
+        }
+    }
+    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "{:?}", self.0)
+        }
+    }
+    impl<T: Msg> tonic::server::NamedService for MsgServer<T> {
+        const NAME: &'static str = "ibc.applications.fee.v1.Msg";
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.controller.v1.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.controller.v1.rs
index fa9a6513..6256c36c 100644
--- a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.controller.v1.rs
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.controller.v1.rs
@@ -1,4 +1,41 @@
-// This file is @generated by prost-build.
+// @generated
+/// Params defines the set of on-chain interchain accounts parameters.
+/// The following parameters may be used to disable the controller submodule.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Params {
+    /// controller_enabled enables or disables the controller submodule.
+    #[prost(bool, tag = "1")]
+    pub controller_enabled: bool,
+}
+/// QueryInterchainAccountRequest is the request type for the Query/InterchainAccount RPC method.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryInterchainAccountRequest {
+    #[prost(string, tag = "1")]
+    pub owner: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub connection_id: ::prost::alloc::string::String,
+}
+/// QueryInterchainAccountResponse the response type for the Query/InterchainAccount RPC method.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryInterchainAccountResponse {
+    #[prost(string, tag = "1")]
+    pub address: ::prost::alloc::string::String,
+}
+/// QueryParamsRequest is the request type for the Query/Params RPC method.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryParamsRequest {}
+/// QueryParamsResponse is the response type for the Query/Params RPC method.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryParamsResponse {
+    /// params defines the parameters of the module.
+    #[prost(message, optional, tag = "1")]
+    pub params: ::core::option::Option<Params>,
+}
 /// MsgRegisterInterchainAccount defines the payload for Msg/MsgRegisterInterchainAccount
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -10,16 +47,6 @@ pub struct MsgRegisterInterchainAccount {
     #[prost(string, tag = "3")]
     pub version: ::prost::alloc::string::String,
 }
-impl ::prost::Name for MsgRegisterInterchainAccount {
-    const NAME: &'static str = "MsgRegisterInterchainAccount";
-    const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccount".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccount".into()
-    }
-}
 /// MsgRegisterInterchainAccountResponse defines the response for Msg/MsgRegisterInterchainAccountResponse
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -27,18 +54,6 @@ pub struct MsgRegisterInterchainAccountResponse {
     #[prost(string, tag = "1")]
     pub channel_id: ::prost::alloc::string::String,
 }
-impl ::prost::Name for MsgRegisterInterchainAccountResponse {
-    const NAME: &'static str = "MsgRegisterInterchainAccountResponse";
-    const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccountResponse"
-            .into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccountResponse"
-            .into()
-    }
-}
 /// MsgSendTx defines the payload for Msg/SendTx
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -54,387 +69,13 @@ pub struct MsgSendTx {
     #[prost(uint64, tag = "4")]
     pub relative_timeout: u64,
 }
-impl ::prost::Name for MsgSendTx {
-    const NAME: &'static str = "MsgSendTx";
-    const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.interchain_accounts.controller.v1.MsgSendTx".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.interchain_accounts.controller.v1.MsgSendTx".into()
-    }
-}
 /// MsgSendTxResponse defines the response for MsgSendTx
 #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, ::prost::Message)]
 pub struct MsgSendTxResponse {
     #[prost(uint64, tag = "1")]
     pub sequence: u64,
 }
-impl ::prost::Name for MsgSendTxResponse {
-    const NAME: &'static str = "MsgSendTxResponse";
-    const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.interchain_accounts.controller.v1.MsgSendTxResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.interchain_accounts.controller.v1.MsgSendTxResponse".into()
-    }
-}
-/// Generated client implementations.
-#[cfg(feature = "grpc")]
-pub mod msg_client {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
-    use tonic::codegen::http::Uri;
-    use tonic::codegen::*;
-    /// Msg defines the 27-interchain-accounts/controller Msg service.
-    #[derive(Debug, Clone)]
-    pub struct MsgClient<T> {
-        inner: tonic::client::Grpc<T>,
-    }
-    #[cfg(feature = "grpc-transport")]
-    impl MsgClient<tonic::transport::Channel> {
-        /// Attempt to create a new client by connecting to a given endpoint.
-        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
-        where
-            D: TryInto<tonic::transport::Endpoint>,
-            D::Error: Into<StdError>,
-        {
-            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
-            Ok(Self::new(conn))
-        }
-    }
-    impl<T> MsgClient<T>
-    where
-        T: tonic::client::GrpcService<tonic::body::BoxBody>,
-        T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(inner: T, interceptor: F) -> MsgClient<InterceptedService<T, F>>
-        where
-            F: tonic::service::Interceptor,
-            T::ResponseBody: Default,
-            T: tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
-                Response = http::Response<
-                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
-                >,
-            >,
-            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
-                Into<StdError> + Send + Sync,
-        {
-            MsgClient::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
-        }
-        /// RegisterInterchainAccount defines a rpc handler for MsgRegisterInterchainAccount.
-        pub async fn register_interchain_account(
-            &mut self,
-            request: impl tonic::IntoRequest<super::MsgRegisterInterchainAccount>,
-        ) -> std::result::Result<
-            tonic::Response<super::MsgRegisterInterchainAccountResponse>,
-            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.controller.v1.Msg/RegisterInterchainAccount",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.applications.interchain_accounts.controller.v1.Msg",
-                "RegisterInterchainAccount",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// SendTx defines a rpc handler for MsgSendTx.
-        pub async fn send_tx(
-            &mut self,
-            request: impl tonic::IntoRequest<super::MsgSendTx>,
-        ) -> std::result::Result<tonic::Response<super::MsgSendTxResponse>, 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.controller.v1.Msg/SendTx",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.applications.interchain_accounts.controller.v1.Msg",
-                "SendTx",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-    }
-}
-/// Params defines the set of on-chain interchain accounts parameters.
-/// The following parameters may be used to disable the controller submodule.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct Params {
-    /// controller_enabled enables or disables the controller submodule.
-    #[prost(bool, tag = "1")]
-    pub controller_enabled: bool,
-}
-impl ::prost::Name for Params {
-    const NAME: &'static str = "Params";
-    const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.interchain_accounts.controller.v1.Params".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.interchain_accounts.controller.v1.Params".into()
-    }
-}
-/// QueryInterchainAccountRequest is the request type for the Query/InterchainAccount RPC method.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct QueryInterchainAccountRequest {
-    #[prost(string, tag = "1")]
-    pub owner: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub connection_id: ::prost::alloc::string::String,
-}
-impl ::prost::Name for QueryInterchainAccountRequest {
-    const NAME: &'static str = "QueryInterchainAccountRequest";
-    const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountRequest".into()
-    }
-}
-/// QueryInterchainAccountResponse the response type for the Query/InterchainAccount RPC method.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct QueryInterchainAccountResponse {
-    #[prost(string, tag = "1")]
-    pub address: ::prost::alloc::string::String,
-}
-impl ::prost::Name for QueryInterchainAccountResponse {
-    const NAME: &'static str = "QueryInterchainAccountResponse";
-    const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountResponse".into()
-    }
-}
-/// QueryParamsRequest is the request type for the Query/Params RPC method.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct QueryParamsRequest {}
-impl ::prost::Name for QueryParamsRequest {
-    const NAME: &'static str = "QueryParamsRequest";
-    const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.interchain_accounts.controller.v1.QueryParamsRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.interchain_accounts.controller.v1.QueryParamsRequest".into()
-    }
-}
-/// QueryParamsResponse is the response type for the Query/Params RPC method.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct QueryParamsResponse {
-    /// params defines the parameters of the module.
-    #[prost(message, optional, tag = "1")]
-    pub params: ::core::option::Option<Params>,
-}
-impl ::prost::Name for QueryParamsResponse {
-    const NAME: &'static str = "QueryParamsResponse";
-    const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.interchain_accounts.controller.v1.QueryParamsResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.interchain_accounts.controller.v1.QueryParamsResponse".into()
-    }
-}
-/// Generated client implementations.
-#[cfg(feature = "grpc")]
-pub mod query_client {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
-    use tonic::codegen::http::Uri;
-    use tonic::codegen::*;
-    /// Query provides defines the gRPC querier service.
-    #[derive(Debug, Clone)]
-    pub struct QueryClient<T> {
-        inner: tonic::client::Grpc<T>,
-    }
-    #[cfg(feature = "grpc-transport")]
-    impl QueryClient<tonic::transport::Channel> {
-        /// Attempt to create a new client by connecting to a given endpoint.
-        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
-        where
-            D: TryInto<tonic::transport::Endpoint>,
-            D::Error: Into<StdError>,
-        {
-            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
-            Ok(Self::new(conn))
-        }
-    }
-    impl<T> QueryClient<T>
-    where
-        T: tonic::client::GrpcService<tonic::body::BoxBody>,
-        T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(
-            inner: T,
-            interceptor: F,
-        ) -> QueryClient<InterceptedService<T, F>>
-        where
-            F: tonic::service::Interceptor,
-            T::ResponseBody: Default,
-            T: tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
-                Response = http::Response<
-                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
-                >,
-            >,
-            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
-                Into<StdError> + Send + Sync,
-        {
-            QueryClient::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
-        }
-        /// InterchainAccount returns the interchain account address for a given owner address on a given connection
-        pub async fn interchain_account(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryInterchainAccountRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::QueryInterchainAccountResponse>,
-            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.controller.v1.Query/InterchainAccount",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.applications.interchain_accounts.controller.v1.Query",
-                "InterchainAccount",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// Params queries all parameters of the ICA controller submodule.
-        pub async fn params(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryParamsRequest>,
-        ) -> std::result::Result<tonic::Response<super::QueryParamsResponse>, 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.controller.v1.Query/Params",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.applications.interchain_accounts.controller.v1.Query",
-                "Params",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-    }
-}
+include!("ibc.applications.interchain_accounts.controller.v1.serde.rs");
+include!("ibc.applications.interchain_accounts.controller.v1.tonic.rs");
+// @@protoc_insertion_point(module)
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.controller.v1.serde.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.controller.v1.serde.rs
new file mode 100644
index 00000000..421ee36a
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.controller.v1.serde.rs
@@ -0,0 +1,1029 @@
+// @generated
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgRegisterInterchainAccount {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.owner.is_empty() {
+            len += 1;
+        }
+        if !self.connection_id.is_empty() {
+            len += 1;
+        }
+        if !self.version.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccount",
+            len,
+        )?;
+        if !self.owner.is_empty() {
+            struct_ser.serialize_field("owner", &self.owner)?;
+        }
+        if !self.connection_id.is_empty() {
+            struct_ser.serialize_field("connectionId", &self.connection_id)?;
+        }
+        if !self.version.is_empty() {
+            struct_ser.serialize_field("version", &self.version)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgRegisterInterchainAccount {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["owner", "connection_id", "connectionId", "version"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Owner,
+            ConnectionId,
+            Version,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "owner" => Ok(GeneratedField::Owner),
+                            "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
+                            "version" => Ok(GeneratedField::Version),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgRegisterInterchainAccount;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccount")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgRegisterInterchainAccount, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut owner__ = None;
+                let mut connection_id__ = None;
+                let mut version__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Owner => {
+                            if owner__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("owner"));
+                            }
+                            owner__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ConnectionId => {
+                            if connection_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("connectionId"));
+                            }
+                            connection_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Version => {
+                            if version__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("version"));
+                            }
+                            version__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgRegisterInterchainAccount {
+                    owner: owner__.unwrap_or_default(),
+                    connection_id: connection_id__.unwrap_or_default(),
+                    version: version__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccount",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgRegisterInterchainAccountResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccountResponse", len)?;
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgRegisterInterchainAccountResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["channel_id", "channelId"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ChannelId,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgRegisterInterchainAccountResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccountResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgRegisterInterchainAccountResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut channel_id__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgRegisterInterchainAccountResponse {
+                    channel_id: channel_id__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccountResponse", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgSendTx {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.owner.is_empty() {
+            len += 1;
+        }
+        if !self.connection_id.is_empty() {
+            len += 1;
+        }
+        if self.packet_data.is_some() {
+            len += 1;
+        }
+        if self.relative_timeout != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.interchain_accounts.controller.v1.MsgSendTx",
+            len,
+        )?;
+        if !self.owner.is_empty() {
+            struct_ser.serialize_field("owner", &self.owner)?;
+        }
+        if !self.connection_id.is_empty() {
+            struct_ser.serialize_field("connectionId", &self.connection_id)?;
+        }
+        if let Some(v) = self.packet_data.as_ref() {
+            struct_ser.serialize_field("packetData", v)?;
+        }
+        if self.relative_timeout != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "relativeTimeout",
+                ToString::to_string(&self.relative_timeout).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgSendTx {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "owner",
+            "connection_id",
+            "connectionId",
+            "packet_data",
+            "packetData",
+            "relative_timeout",
+            "relativeTimeout",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Owner,
+            ConnectionId,
+            PacketData,
+            RelativeTimeout,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "owner" => Ok(GeneratedField::Owner),
+                            "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
+                            "packetData" | "packet_data" => Ok(GeneratedField::PacketData),
+                            "relativeTimeout" | "relative_timeout" => {
+                                Ok(GeneratedField::RelativeTimeout)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgSendTx;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str(
+                    "struct ibc.applications.interchain_accounts.controller.v1.MsgSendTx",
+                )
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MsgSendTx, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut owner__ = None;
+                let mut connection_id__ = None;
+                let mut packet_data__ = None;
+                let mut relative_timeout__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Owner => {
+                            if owner__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("owner"));
+                            }
+                            owner__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ConnectionId => {
+                            if connection_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("connectionId"));
+                            }
+                            connection_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::PacketData => {
+                            if packet_data__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("packetData"));
+                            }
+                            packet_data__ = map_.next_value()?;
+                        }
+                        GeneratedField::RelativeTimeout => {
+                            if relative_timeout__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("relativeTimeout"));
+                            }
+                            relative_timeout__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(MsgSendTx {
+                    owner: owner__.unwrap_or_default(),
+                    connection_id: connection_id__.unwrap_or_default(),
+                    packet_data: packet_data__,
+                    relative_timeout: relative_timeout__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.interchain_accounts.controller.v1.MsgSendTx",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgSendTxResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.sequence != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.interchain_accounts.controller.v1.MsgSendTxResponse",
+            len,
+        )?;
+        if self.sequence != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("sequence", ToString::to_string(&self.sequence).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgSendTxResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["sequence"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Sequence,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "sequence" => Ok(GeneratedField::Sequence),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgSendTxResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str(
+                    "struct ibc.applications.interchain_accounts.controller.v1.MsgSendTxResponse",
+                )
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MsgSendTxResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut sequence__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Sequence => {
+                            if sequence__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sequence"));
+                            }
+                            sequence__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(MsgSendTxResponse {
+                    sequence: sequence__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.interchain_accounts.controller.v1.MsgSendTxResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Params {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.controller_enabled {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.interchain_accounts.controller.v1.Params",
+            len,
+        )?;
+        if self.controller_enabled {
+            struct_ser.serialize_field("controllerEnabled", &self.controller_enabled)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Params {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["controller_enabled", "controllerEnabled"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ControllerEnabled,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "controllerEnabled" | "controller_enabled" => {
+                                Ok(GeneratedField::ControllerEnabled)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Params;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter
+                    .write_str("struct ibc.applications.interchain_accounts.controller.v1.Params")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Params, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut controller_enabled__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ControllerEnabled => {
+                            if controller_enabled__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("controllerEnabled"));
+                            }
+                            controller_enabled__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(Params {
+                    controller_enabled: controller_enabled__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.interchain_accounts.controller.v1.Params",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryInterchainAccountRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.owner.is_empty() {
+            len += 1;
+        }
+        if !self.connection_id.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountRequest",
+            len,
+        )?;
+        if !self.owner.is_empty() {
+            struct_ser.serialize_field("owner", &self.owner)?;
+        }
+        if !self.connection_id.is_empty() {
+            struct_ser.serialize_field("connectionId", &self.connection_id)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryInterchainAccountRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["owner", "connection_id", "connectionId"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Owner,
+            ConnectionId,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "owner" => Ok(GeneratedField::Owner),
+                            "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryInterchainAccountRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryInterchainAccountRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut owner__ = None;
+                let mut connection_id__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Owner => {
+                            if owner__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("owner"));
+                            }
+                            owner__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ConnectionId => {
+                            if connection_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("connectionId"));
+                            }
+                            connection_id__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryInterchainAccountRequest {
+                    owner: owner__.unwrap_or_default(),
+                    connection_id: connection_id__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryInterchainAccountResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.address.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountResponse",
+            len,
+        )?;
+        if !self.address.is_empty() {
+            struct_ser.serialize_field("address", &self.address)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryInterchainAccountResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["address"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Address,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "address" => Ok(GeneratedField::Address),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryInterchainAccountResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryInterchainAccountResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut address__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Address => {
+                            if address__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("address"));
+                            }
+                            address__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryInterchainAccountResponse {
+                    address: address__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryParamsRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser = serializer.serialize_struct(
+            "ibc.applications.interchain_accounts.controller.v1.QueryParamsRequest",
+            len,
+        )?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryParamsRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryParamsRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str(
+                    "struct ibc.applications.interchain_accounts.controller.v1.QueryParamsRequest",
+                )
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<QueryParamsRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(QueryParamsRequest {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.interchain_accounts.controller.v1.QueryParamsRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryParamsResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.params.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.interchain_accounts.controller.v1.QueryParamsResponse",
+            len,
+        )?;
+        if let Some(v) = self.params.as_ref() {
+            struct_ser.serialize_field("params", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryParamsResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["params"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Params,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "params" => Ok(GeneratedField::Params),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryParamsResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str(
+                    "struct ibc.applications.interchain_accounts.controller.v1.QueryParamsResponse",
+                )
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<QueryParamsResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut params__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Params => {
+                            if params__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("params"));
+                            }
+                            params__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryParamsResponse { params: params__ })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.interchain_accounts.controller.v1.QueryParamsResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.controller.v1.tonic.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.controller.v1.tonic.rs
new file mode 100644
index 00000000..6d03bc15
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.controller.v1.tonic.rs
@@ -0,0 +1,701 @@
+// @generated
+/// Generated client implementations.
+#[cfg(feature = "grpc")]
+pub mod query_client {
+    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
+    use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
+    #[derive(Debug, Clone)]
+    pub struct QueryClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    #[cfg(feature = "grpc-transport")]
+    impl QueryClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> QueryClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> QueryClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
+                Into<StdError> + Send + Sync,
+        {
+            QueryClient::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
+        }
+        pub async fn interchain_account(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryInterchainAccountRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryInterchainAccountResponse>,
+            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.controller.v1.Query/InterchainAccount",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.applications.interchain_accounts.controller.v1.Query",
+                "InterchainAccount",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn params(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryParamsRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryParamsResponse>, 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.controller.v1.Query/Params",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.applications.interchain_accounts.controller.v1.Query",
+                "Params",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+#[cfg(feature = "grpc")]
+pub mod query_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 QueryServer.
+    #[async_trait]
+    pub trait Query: Send + Sync + 'static {
+        async fn interchain_account(
+            &self,
+            request: tonic::Request<super::QueryInterchainAccountRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryInterchainAccountResponse>,
+            tonic::Status,
+        >;
+        async fn params(
+            &self,
+            request: tonic::Request<super::QueryParamsRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryParamsResponse>, tonic::Status>;
+    }
+    #[derive(Debug)]
+    pub struct QueryServer<T: Query> {
+        inner: _Inner<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    struct _Inner<T>(Arc<T>);
+    impl<T: Query> QueryServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            let inner = _Inner(inner);
+            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<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
+        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<T, B> tonic::codegen::Service<http::Request<B>> for QueryServer<T>
+    where
+        T: Query,
+        B: Body + Send + 'static,
+        B::Error: Into<StdError> + Send + 'static,
+    {
+        type Response = http::Response<tonic::body::BoxBody>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            let inner = self.inner.clone();
+            match req.uri().path() {
+                "/ibc.applications.interchain_accounts.controller.v1.Query/InterchainAccount" => {
+                    #[allow(non_camel_case_types)]
+                    struct InterchainAccountSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryInterchainAccountRequest>
+                        for InterchainAccountSvc<T>
+                    {
+                        type Response = super::QueryInterchainAccountResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryInterchainAccountRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).interchain_account(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 = InterchainAccountSvc(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.interchain_accounts.controller.v1.Query/Params" => {
+                    #[allow(non_camel_case_types)]
+                    struct ParamsSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryParamsRequest> for ParamsSvc<T> {
+                        type Response = super::QueryParamsResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryParamsRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).params(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 = ParamsSvc(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", "12")
+                        .header("content-type", "application/grpc")
+                        .body(empty_body())
+                        .unwrap())
+                }),
+            }
+        }
+    }
+    impl<T: Query> Clone for QueryServer<T> {
+        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<T: Query> Clone for _Inner<T> {
+        fn clone(&self) -> Self {
+            Self(Arc::clone(&self.0))
+        }
+    }
+    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "{:?}", self.0)
+        }
+    }
+    impl<T: Query> tonic::server::NamedService for QueryServer<T> {
+        const NAME: &'static str = "ibc.applications.interchain_accounts.controller.v1.Query";
+    }
+}
+/// Generated client implementations.
+#[cfg(feature = "grpc")]
+pub mod msg_client {
+    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
+    use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
+    #[derive(Debug, Clone)]
+    pub struct MsgClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    #[cfg(feature = "grpc-transport")]
+    impl MsgClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> MsgClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(inner: T, interceptor: F) -> MsgClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
+                Into<StdError> + Send + Sync,
+        {
+            MsgClient::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
+        }
+        pub async fn register_interchain_account(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgRegisterInterchainAccount>,
+        ) -> std::result::Result<
+            tonic::Response<super::MsgRegisterInterchainAccountResponse>,
+            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.controller.v1.Msg/RegisterInterchainAccount",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.applications.interchain_accounts.controller.v1.Msg",
+                "RegisterInterchainAccount",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn send_tx(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgSendTx>,
+        ) -> std::result::Result<tonic::Response<super::MsgSendTxResponse>, 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.controller.v1.Msg/SendTx",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.applications.interchain_accounts.controller.v1.Msg",
+                "SendTx",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+#[cfg(feature = "grpc")]
+pub mod msg_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 MsgServer.
+    #[async_trait]
+    pub trait Msg: Send + Sync + 'static {
+        async fn register_interchain_account(
+            &self,
+            request: tonic::Request<super::MsgRegisterInterchainAccount>,
+        ) -> std::result::Result<
+            tonic::Response<super::MsgRegisterInterchainAccountResponse>,
+            tonic::Status,
+        >;
+        async fn send_tx(
+            &self,
+            request: tonic::Request<super::MsgSendTx>,
+        ) -> std::result::Result<tonic::Response<super::MsgSendTxResponse>, tonic::Status>;
+    }
+    #[derive(Debug)]
+    pub struct MsgServer<T: Msg> {
+        inner: _Inner<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    struct _Inner<T>(Arc<T>);
+    impl<T: Msg> MsgServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            let inner = _Inner(inner);
+            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<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
+        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<T, B> tonic::codegen::Service<http::Request<B>> for MsgServer<T>
+    where
+        T: Msg,
+        B: Body + Send + 'static,
+        B::Error: Into<StdError> + Send + 'static,
+    {
+        type Response = http::Response<tonic::body::BoxBody>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            let inner = self.inner.clone();
+            match req.uri().path() {
+                "/ibc.applications.interchain_accounts.controller.v1.Msg/RegisterInterchainAccount" => {
+                    #[allow(non_camel_case_types)]
+                    struct RegisterInterchainAccountSvc<T: Msg>(pub Arc<T>);
+                    impl<
+                        T: Msg,
+                    > tonic::server::UnaryService<super::MsgRegisterInterchainAccount>
+                    for RegisterInterchainAccountSvc<T> {
+                        type Response = super::MsgRegisterInterchainAccountResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgRegisterInterchainAccount>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                (*inner).register_interchain_account(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 = RegisterInterchainAccountSvc(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.interchain_accounts.controller.v1.Msg/SendTx" => {
+                    #[allow(non_camel_case_types)]
+                    struct SendTxSvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgSendTx>
+                    for SendTxSvc<T> {
+                        type Response = super::MsgSendTxResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgSendTx>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).send_tx(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 = SendTxSvc(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", "12")
+                                .header("content-type", "application/grpc")
+                                .body(empty_body())
+                                .unwrap(),
+                        )
+                    })
+                }
+            }
+        }
+    }
+    impl<T: Msg> Clone for MsgServer<T> {
+        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<T: Msg> Clone for _Inner<T> {
+        fn clone(&self) -> Self {
+            Self(Arc::clone(&self.0))
+        }
+    }
+    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "{:?}", self.0)
+        }
+    }
+    impl<T: Msg> tonic::server::NamedService for MsgServer<T> {
+        const NAME: &'static str = "ibc.applications.interchain_accounts.controller.v1.Msg";
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.genesis.v1.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.genesis.v1.rs
index e43983a9..f7f7e1cb 100644
--- a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.genesis.v1.rs
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.genesis.v1.rs
@@ -1,4 +1,4 @@
-// This file is @generated by prost-build.
+// @generated
 /// GenesisState defines the interchain accounts genesis state
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -8,16 +8,6 @@ pub struct GenesisState {
     #[prost(message, optional, tag = "2")]
     pub host_genesis_state: ::core::option::Option<HostGenesisState>,
 }
-impl ::prost::Name for GenesisState {
-    const NAME: &'static str = "GenesisState";
-    const PACKAGE: &'static str = "ibc.applications.interchain_accounts.genesis.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.interchain_accounts.genesis.v1.GenesisState".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.interchain_accounts.genesis.v1.GenesisState".into()
-    }
-}
 /// ControllerGenesisState defines the interchain accounts controller genesis state
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -31,16 +21,6 @@ pub struct ControllerGenesisState {
     #[prost(message, optional, tag = "4")]
     pub params: ::core::option::Option<super::super::controller::v1::Params>,
 }
-impl ::prost::Name for ControllerGenesisState {
-    const NAME: &'static str = "ControllerGenesisState";
-    const PACKAGE: &'static str = "ibc.applications.interchain_accounts.genesis.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.interchain_accounts.genesis.v1.ControllerGenesisState".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.interchain_accounts.genesis.v1.ControllerGenesisState".into()
-    }
-}
 /// HostGenesisState defines the interchain accounts host genesis state
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -54,16 +34,6 @@ pub struct HostGenesisState {
     #[prost(message, optional, tag = "4")]
     pub params: ::core::option::Option<super::super::host::v1::Params>,
 }
-impl ::prost::Name for HostGenesisState {
-    const NAME: &'static str = "HostGenesisState";
-    const PACKAGE: &'static str = "ibc.applications.interchain_accounts.genesis.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.interchain_accounts.genesis.v1.HostGenesisState".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.interchain_accounts.genesis.v1.HostGenesisState".into()
-    }
-}
 /// ActiveChannel contains a connection ID, port ID and associated active channel ID, as well as a boolean flag to
 /// indicate if the channel is middleware enabled
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -78,16 +48,6 @@ pub struct ActiveChannel {
     #[prost(bool, tag = "4")]
     pub is_middleware_enabled: bool,
 }
-impl ::prost::Name for ActiveChannel {
-    const NAME: &'static str = "ActiveChannel";
-    const PACKAGE: &'static str = "ibc.applications.interchain_accounts.genesis.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.interchain_accounts.genesis.v1.ActiveChannel".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.interchain_accounts.genesis.v1.ActiveChannel".into()
-    }
-}
 /// RegisteredInterchainAccount contains a connection ID, port ID and associated interchain account address
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -99,13 +59,5 @@ pub struct RegisteredInterchainAccount {
     #[prost(string, tag = "3")]
     pub account_address: ::prost::alloc::string::String,
 }
-impl ::prost::Name for RegisteredInterchainAccount {
-    const NAME: &'static str = "RegisteredInterchainAccount";
-    const PACKAGE: &'static str = "ibc.applications.interchain_accounts.genesis.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.interchain_accounts.genesis.v1.RegisteredInterchainAccount".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.interchain_accounts.genesis.v1.RegisteredInterchainAccount".into()
-    }
-}
+include!("ibc.applications.interchain_accounts.genesis.v1.serde.rs");
+// @@protoc_insertion_point(module)
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.genesis.v1.serde.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.genesis.v1.serde.rs
new file mode 100644
index 00000000..d2cf8bac
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.genesis.v1.serde.rs
@@ -0,0 +1,776 @@
+// @generated
+#[cfg(feature = "serde")]
+impl serde::Serialize for ActiveChannel {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.connection_id.is_empty() {
+            len += 1;
+        }
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if self.is_middleware_enabled {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.interchain_accounts.genesis.v1.ActiveChannel",
+            len,
+        )?;
+        if !self.connection_id.is_empty() {
+            struct_ser.serialize_field("connectionId", &self.connection_id)?;
+        }
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if self.is_middleware_enabled {
+            struct_ser.serialize_field("isMiddlewareEnabled", &self.is_middleware_enabled)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ActiveChannel {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "connection_id",
+            "connectionId",
+            "port_id",
+            "portId",
+            "channel_id",
+            "channelId",
+            "is_middleware_enabled",
+            "isMiddlewareEnabled",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ConnectionId,
+            PortId,
+            ChannelId,
+            IsMiddlewareEnabled,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "isMiddlewareEnabled" | "is_middleware_enabled" => {
+                                Ok(GeneratedField::IsMiddlewareEnabled)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ActiveChannel;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str(
+                    "struct ibc.applications.interchain_accounts.genesis.v1.ActiveChannel",
+                )
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActiveChannel, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut connection_id__ = None;
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                let mut is_middleware_enabled__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ConnectionId => {
+                            if connection_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("connectionId"));
+                            }
+                            connection_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::IsMiddlewareEnabled => {
+                            if is_middleware_enabled__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "isMiddlewareEnabled",
+                                ));
+                            }
+                            is_middleware_enabled__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(ActiveChannel {
+                    connection_id: connection_id__.unwrap_or_default(),
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                    is_middleware_enabled: is_middleware_enabled__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.interchain_accounts.genesis.v1.ActiveChannel",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for ControllerGenesisState {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.active_channels.is_empty() {
+            len += 1;
+        }
+        if !self.interchain_accounts.is_empty() {
+            len += 1;
+        }
+        if !self.ports.is_empty() {
+            len += 1;
+        }
+        if self.params.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.interchain_accounts.genesis.v1.ControllerGenesisState",
+            len,
+        )?;
+        if !self.active_channels.is_empty() {
+            struct_ser.serialize_field("activeChannels", &self.active_channels)?;
+        }
+        if !self.interchain_accounts.is_empty() {
+            struct_ser.serialize_field("interchainAccounts", &self.interchain_accounts)?;
+        }
+        if !self.ports.is_empty() {
+            struct_ser.serialize_field("ports", &self.ports)?;
+        }
+        if let Some(v) = self.params.as_ref() {
+            struct_ser.serialize_field("params", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ControllerGenesisState {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "active_channels",
+            "activeChannels",
+            "interchain_accounts",
+            "interchainAccounts",
+            "ports",
+            "params",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ActiveChannels,
+            InterchainAccounts,
+            Ports,
+            Params,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "activeChannels" | "active_channels" => {
+                                Ok(GeneratedField::ActiveChannels)
+                            }
+                            "interchainAccounts" | "interchain_accounts" => {
+                                Ok(GeneratedField::InterchainAccounts)
+                            }
+                            "ports" => Ok(GeneratedField::Ports),
+                            "params" => Ok(GeneratedField::Params),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ControllerGenesisState;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str(
+                    "struct ibc.applications.interchain_accounts.genesis.v1.ControllerGenesisState",
+                )
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<ControllerGenesisState, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut active_channels__ = None;
+                let mut interchain_accounts__ = None;
+                let mut ports__ = None;
+                let mut params__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ActiveChannels => {
+                            if active_channels__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("activeChannels"));
+                            }
+                            active_channels__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::InterchainAccounts => {
+                            if interchain_accounts__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "interchainAccounts",
+                                ));
+                            }
+                            interchain_accounts__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Ports => {
+                            if ports__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("ports"));
+                            }
+                            ports__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Params => {
+                            if params__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("params"));
+                            }
+                            params__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(ControllerGenesisState {
+                    active_channels: active_channels__.unwrap_or_default(),
+                    interchain_accounts: interchain_accounts__.unwrap_or_default(),
+                    ports: ports__.unwrap_or_default(),
+                    params: params__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.interchain_accounts.genesis.v1.ControllerGenesisState",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for GenesisState {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.controller_genesis_state.is_some() {
+            len += 1;
+        }
+        if self.host_genesis_state.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.interchain_accounts.genesis.v1.GenesisState",
+            len,
+        )?;
+        if let Some(v) = self.controller_genesis_state.as_ref() {
+            struct_ser.serialize_field("controllerGenesisState", v)?;
+        }
+        if let Some(v) = self.host_genesis_state.as_ref() {
+            struct_ser.serialize_field("hostGenesisState", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for GenesisState {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "controller_genesis_state",
+            "controllerGenesisState",
+            "host_genesis_state",
+            "hostGenesisState",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ControllerGenesisState,
+            HostGenesisState,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "controllerGenesisState" | "controller_genesis_state" => {
+                                Ok(GeneratedField::ControllerGenesisState)
+                            }
+                            "hostGenesisState" | "host_genesis_state" => {
+                                Ok(GeneratedField::HostGenesisState)
+                            }
+                            _ => 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 std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str(
+                    "struct ibc.applications.interchain_accounts.genesis.v1.GenesisState",
+                )
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GenesisState, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut controller_genesis_state__ = None;
+                let mut host_genesis_state__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ControllerGenesisState => {
+                            if controller_genesis_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "controllerGenesisState",
+                                ));
+                            }
+                            controller_genesis_state__ = map_.next_value()?;
+                        }
+                        GeneratedField::HostGenesisState => {
+                            if host_genesis_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("hostGenesisState"));
+                            }
+                            host_genesis_state__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(GenesisState {
+                    controller_genesis_state: controller_genesis_state__,
+                    host_genesis_state: host_genesis_state__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.interchain_accounts.genesis.v1.GenesisState",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for HostGenesisState {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.active_channels.is_empty() {
+            len += 1;
+        }
+        if !self.interchain_accounts.is_empty() {
+            len += 1;
+        }
+        if !self.port.is_empty() {
+            len += 1;
+        }
+        if self.params.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.interchain_accounts.genesis.v1.HostGenesisState",
+            len,
+        )?;
+        if !self.active_channels.is_empty() {
+            struct_ser.serialize_field("activeChannels", &self.active_channels)?;
+        }
+        if !self.interchain_accounts.is_empty() {
+            struct_ser.serialize_field("interchainAccounts", &self.interchain_accounts)?;
+        }
+        if !self.port.is_empty() {
+            struct_ser.serialize_field("port", &self.port)?;
+        }
+        if let Some(v) = self.params.as_ref() {
+            struct_ser.serialize_field("params", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for HostGenesisState {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "active_channels",
+            "activeChannels",
+            "interchain_accounts",
+            "interchainAccounts",
+            "port",
+            "params",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ActiveChannels,
+            InterchainAccounts,
+            Port,
+            Params,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "activeChannels" | "active_channels" => {
+                                Ok(GeneratedField::ActiveChannels)
+                            }
+                            "interchainAccounts" | "interchain_accounts" => {
+                                Ok(GeneratedField::InterchainAccounts)
+                            }
+                            "port" => Ok(GeneratedField::Port),
+                            "params" => Ok(GeneratedField::Params),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = HostGenesisState;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str(
+                    "struct ibc.applications.interchain_accounts.genesis.v1.HostGenesisState",
+                )
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HostGenesisState, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut active_channels__ = None;
+                let mut interchain_accounts__ = None;
+                let mut port__ = None;
+                let mut params__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ActiveChannels => {
+                            if active_channels__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("activeChannels"));
+                            }
+                            active_channels__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::InterchainAccounts => {
+                            if interchain_accounts__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "interchainAccounts",
+                                ));
+                            }
+                            interchain_accounts__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Port => {
+                            if port__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("port"));
+                            }
+                            port__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Params => {
+                            if params__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("params"));
+                            }
+                            params__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(HostGenesisState {
+                    active_channels: active_channels__.unwrap_or_default(),
+                    interchain_accounts: interchain_accounts__.unwrap_or_default(),
+                    port: port__.unwrap_or_default(),
+                    params: params__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.interchain_accounts.genesis.v1.HostGenesisState",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for RegisteredInterchainAccount {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.connection_id.is_empty() {
+            len += 1;
+        }
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.account_address.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.interchain_accounts.genesis.v1.RegisteredInterchainAccount",
+            len,
+        )?;
+        if !self.connection_id.is_empty() {
+            struct_ser.serialize_field("connectionId", &self.connection_id)?;
+        }
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.account_address.is_empty() {
+            struct_ser.serialize_field("accountAddress", &self.account_address)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for RegisteredInterchainAccount {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "connection_id",
+            "connectionId",
+            "port_id",
+            "portId",
+            "account_address",
+            "accountAddress",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ConnectionId,
+            PortId,
+            AccountAddress,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "accountAddress" | "account_address" => {
+                                Ok(GeneratedField::AccountAddress)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = RegisteredInterchainAccount;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.interchain_accounts.genesis.v1.RegisteredInterchainAccount")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<RegisteredInterchainAccount, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut connection_id__ = None;
+                let mut port_id__ = None;
+                let mut account_address__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ConnectionId => {
+                            if connection_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("connectionId"));
+                            }
+                            connection_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::AccountAddress => {
+                            if account_address__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("accountAddress"));
+                            }
+                            account_address__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(RegisteredInterchainAccount {
+                    connection_id: connection_id__.unwrap_or_default(),
+                    port_id: port_id__.unwrap_or_default(),
+                    account_address: account_address__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.interchain_accounts.genesis.v1.RegisteredInterchainAccount",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.host.v1.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.host.v1.rs
index e06818ed..1abb5f46 100644
--- a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.host.v1.rs
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.host.v1.rs
@@ -1,4 +1,4 @@
-// This file is @generated by prost-build.
+// @generated
 /// Params defines the set of on-chain interchain accounts parameters.
 /// The following parameters may be used to disable the host submodule.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -11,30 +11,10 @@ pub struct Params {
     #[prost(string, repeated, tag = "2")]
     pub allow_messages: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
 }
-impl ::prost::Name for Params {
-    const NAME: &'static str = "Params";
-    const PACKAGE: &'static str = "ibc.applications.interchain_accounts.host.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.interchain_accounts.host.v1.Params".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.interchain_accounts.host.v1.Params".into()
-    }
-}
 /// QueryParamsRequest is the request type for the Query/Params RPC method.
 #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, ::prost::Message)]
 pub struct QueryParamsRequest {}
-impl ::prost::Name for QueryParamsRequest {
-    const NAME: &'static str = "QueryParamsRequest";
-    const PACKAGE: &'static str = "ibc.applications.interchain_accounts.host.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.interchain_accounts.host.v1.QueryParamsRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.interchain_accounts.host.v1.QueryParamsRequest".into()
-    }
-}
 /// QueryParamsResponse is the response type for the Query/Params RPC method.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -43,125 +23,6 @@ pub struct QueryParamsResponse {
     #[prost(message, optional, tag = "1")]
     pub params: ::core::option::Option<Params>,
 }
-impl ::prost::Name for QueryParamsResponse {
-    const NAME: &'static str = "QueryParamsResponse";
-    const PACKAGE: &'static str = "ibc.applications.interchain_accounts.host.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.interchain_accounts.host.v1.QueryParamsResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.interchain_accounts.host.v1.QueryParamsResponse".into()
-    }
-}
-/// Generated client implementations.
-#[cfg(feature = "grpc")]
-pub mod query_client {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
-    use tonic::codegen::http::Uri;
-    use tonic::codegen::*;
-    /// Query provides defines the gRPC querier service.
-    #[derive(Debug, Clone)]
-    pub struct QueryClient<T> {
-        inner: tonic::client::Grpc<T>,
-    }
-    #[cfg(feature = "grpc-transport")]
-    impl QueryClient<tonic::transport::Channel> {
-        /// Attempt to create a new client by connecting to a given endpoint.
-        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
-        where
-            D: TryInto<tonic::transport::Endpoint>,
-            D::Error: Into<StdError>,
-        {
-            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
-            Ok(Self::new(conn))
-        }
-    }
-    impl<T> QueryClient<T>
-    where
-        T: tonic::client::GrpcService<tonic::body::BoxBody>,
-        T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(
-            inner: T,
-            interceptor: F,
-        ) -> QueryClient<InterceptedService<T, F>>
-        where
-            F: tonic::service::Interceptor,
-            T::ResponseBody: Default,
-            T: tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
-                Response = http::Response<
-                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
-                >,
-            >,
-            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
-                Into<StdError> + Send + Sync,
-        {
-            QueryClient::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
-        }
-        /// Params queries all parameters of the ICA host submodule.
-        pub async fn params(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryParamsRequest>,
-        ) -> std::result::Result<tonic::Response<super::QueryParamsResponse>, 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.Query/Params",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.applications.interchain_accounts.host.v1.Query",
-                "Params",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-    }
-}
+include!("ibc.applications.interchain_accounts.host.v1.serde.rs");
+include!("ibc.applications.interchain_accounts.host.v1.tonic.rs");
+// @@protoc_insertion_point(module)
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.host.v1.serde.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.host.v1.serde.rs
new file mode 100644
index 00000000..99282c4c
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.host.v1.serde.rs
@@ -0,0 +1,307 @@
+// @generated
+#[cfg(feature = "serde")]
+impl serde::Serialize for Params {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.host_enabled {
+            len += 1;
+        }
+        if !self.allow_messages.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.applications.interchain_accounts.host.v1.Params", len)?;
+        if self.host_enabled {
+            struct_ser.serialize_field("hostEnabled", &self.host_enabled)?;
+        }
+        if !self.allow_messages.is_empty() {
+            struct_ser.serialize_field("allowMessages", &self.allow_messages)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Params {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "host_enabled",
+            "hostEnabled",
+            "allow_messages",
+            "allowMessages",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            HostEnabled,
+            AllowMessages,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "hostEnabled" | "host_enabled" => Ok(GeneratedField::HostEnabled),
+                            "allowMessages" | "allow_messages" => Ok(GeneratedField::AllowMessages),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Params;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.interchain_accounts.host.v1.Params")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Params, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut host_enabled__ = None;
+                let mut allow_messages__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::HostEnabled => {
+                            if host_enabled__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("hostEnabled"));
+                            }
+                            host_enabled__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::AllowMessages => {
+                            if allow_messages__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("allowMessages"));
+                            }
+                            allow_messages__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(Params {
+                    host_enabled: host_enabled__.unwrap_or_default(),
+                    allow_messages: allow_messages__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.interchain_accounts.host.v1.Params",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryParamsRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser = serializer.serialize_struct(
+            "ibc.applications.interchain_accounts.host.v1.QueryParamsRequest",
+            len,
+        )?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryParamsRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryParamsRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str(
+                    "struct ibc.applications.interchain_accounts.host.v1.QueryParamsRequest",
+                )
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<QueryParamsRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(QueryParamsRequest {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.interchain_accounts.host.v1.QueryParamsRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryParamsResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.params.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.interchain_accounts.host.v1.QueryParamsResponse",
+            len,
+        )?;
+        if let Some(v) = self.params.as_ref() {
+            struct_ser.serialize_field("params", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryParamsResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["params"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Params,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "params" => Ok(GeneratedField::Params),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryParamsResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str(
+                    "struct ibc.applications.interchain_accounts.host.v1.QueryParamsResponse",
+                )
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<QueryParamsResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut params__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Params => {
+                            if params__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("params"));
+                            }
+                            params__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryParamsResponse { params: params__ })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.interchain_accounts.host.v1.QueryParamsResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.host.v1.tonic.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.host.v1.tonic.rs
new file mode 100644
index 00000000..2e57e67f
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.host.v1.tonic.rs
@@ -0,0 +1,283 @@
+// @generated
+/// Generated client implementations.
+#[cfg(feature = "grpc")]
+pub mod query_client {
+    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
+    use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
+    /** Query provides defines the gRPC querier service.
+    */
+    #[derive(Debug, Clone)]
+    pub struct QueryClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    #[cfg(feature = "grpc-transport")]
+    impl QueryClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> QueryClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> QueryClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
+                Into<StdError> + Send + Sync,
+        {
+            QueryClient::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
+        }
+        /** Params queries all parameters of the ICA host submodule.
+        */
+        pub async fn params(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryParamsRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryParamsResponse>, 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.Query/Params",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.applications.interchain_accounts.host.v1.Query",
+                "Params",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+#[cfg(feature = "grpc")]
+pub mod query_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 QueryServer.
+    #[async_trait]
+    pub trait Query: Send + Sync + 'static {
+        /** Params queries all parameters of the ICA host submodule.
+        */
+        async fn params(
+            &self,
+            request: tonic::Request<super::QueryParamsRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryParamsResponse>, tonic::Status>;
+    }
+    /** Query provides defines the gRPC querier service.
+    */
+    #[derive(Debug)]
+    pub struct QueryServer<T: Query> {
+        inner: _Inner<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    struct _Inner<T>(Arc<T>);
+    impl<T: Query> QueryServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            let inner = _Inner(inner);
+            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<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
+        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<T, B> tonic::codegen::Service<http::Request<B>> for QueryServer<T>
+    where
+        T: Query,
+        B: Body + Send + 'static,
+        B::Error: Into<StdError> + Send + 'static,
+    {
+        type Response = http::Response<tonic::body::BoxBody>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            let inner = self.inner.clone();
+            match req.uri().path() {
+                "/ibc.applications.interchain_accounts.host.v1.Query/Params" => {
+                    #[allow(non_camel_case_types)]
+                    struct ParamsSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryParamsRequest> for ParamsSvc<T> {
+                        type Response = super::QueryParamsResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryParamsRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).params(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 = ParamsSvc(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", "12")
+                        .header("content-type", "application/grpc")
+                        .body(empty_body())
+                        .unwrap())
+                }),
+            }
+        }
+    }
+    impl<T: Query> Clone for QueryServer<T> {
+        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<T: Query> Clone for _Inner<T> {
+        fn clone(&self) -> Self {
+            Self(Arc::clone(&self.0))
+        }
+    }
+    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "{:?}", self.0)
+        }
+    }
+    impl<T: Query> tonic::server::NamedService for QueryServer<T> {
+        const NAME: &'static str = "ibc.applications.interchain_accounts.host.v1.Query";
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.v1.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.v1.rs
index 9f163fc5..5a3204bb 100644
--- a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.v1.rs
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.v1.rs
@@ -1,24 +1,4 @@
-// This file is @generated by prost-build.
-/// An InterchainAccount is defined as a BaseAccount & the address of the account owner on the controller chain
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct InterchainAccount {
-    #[prost(message, optional, tag = "1")]
-    pub base_account:
-        ::core::option::Option<super::super::super::super::cosmos::auth::v1beta1::BaseAccount>,
-    #[prost(string, tag = "2")]
-    pub account_owner: ::prost::alloc::string::String,
-}
-impl ::prost::Name for InterchainAccount {
-    const NAME: &'static str = "InterchainAccount";
-    const PACKAGE: &'static str = "ibc.applications.interchain_accounts.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.interchain_accounts.v1.InterchainAccount".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.interchain_accounts.v1.InterchainAccount".into()
-    }
-}
+// @generated
 /// InterchainAccountPacketData is comprised of a raw transaction, type of transaction and optional memo field.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -30,16 +10,6 @@ pub struct InterchainAccountPacketData {
     #[prost(string, tag = "3")]
     pub memo: ::prost::alloc::string::String,
 }
-impl ::prost::Name for InterchainAccountPacketData {
-    const NAME: &'static str = "InterchainAccountPacketData";
-    const PACKAGE: &'static str = "ibc.applications.interchain_accounts.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.interchain_accounts.v1.InterchainAccountPacketData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.interchain_accounts.v1.InterchainAccountPacketData".into()
-    }
-}
 /// CosmosTx contains a list of sdk.Msg's. It should be used when sending transactions to an SDK host chain.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -47,16 +17,6 @@ pub struct CosmosTx {
     #[prost(message, repeated, tag = "1")]
     pub messages: ::prost::alloc::vec::Vec<::tendermint_proto::google::protobuf::Any>,
 }
-impl ::prost::Name for CosmosTx {
-    const NAME: &'static str = "CosmosTx";
-    const PACKAGE: &'static str = "ibc.applications.interchain_accounts.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.interchain_accounts.v1.CosmosTx".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.interchain_accounts.v1.CosmosTx".into()
-    }
-}
 /// Type defines a classification of message issued from a controller chain to its associated interchain accounts
 /// host
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
@@ -87,6 +47,16 @@ impl Type {
         }
     }
 }
+/// An InterchainAccount is defined as a BaseAccount & the address of the account owner on the controller chain
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct InterchainAccount {
+    #[prost(message, optional, tag = "1")]
+    pub base_account:
+        ::core::option::Option<super::super::super::super::cosmos::auth::v1beta1::BaseAccount>,
+    #[prost(string, tag = "2")]
+    pub account_owner: ::prost::alloc::string::String,
+}
 /// Metadata defines a set of protocol specific data encoded into the ICS27 channel version bytestring
 /// See ICS004: <https://github.com/cosmos/ibc/tree/master/spec/core/ics-004-channel-and-packet-semantics#Versioning>
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -112,13 +82,5 @@ pub struct Metadata {
     #[prost(string, tag = "6")]
     pub tx_type: ::prost::alloc::string::String,
 }
-impl ::prost::Name for Metadata {
-    const NAME: &'static str = "Metadata";
-    const PACKAGE: &'static str = "ibc.applications.interchain_accounts.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.interchain_accounts.v1.Metadata".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.interchain_accounts.v1.Metadata".into()
-    }
-}
+include!("ibc.applications.interchain_accounts.v1.serde.rs");
+// @@protoc_insertion_point(module)
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.v1.serde.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.v1.serde.rs
new file mode 100644
index 00000000..487f5649
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.interchain_accounts.v1.serde.rs
@@ -0,0 +1,638 @@
+// @generated
+#[cfg(feature = "serde")]
+impl serde::Serialize for CosmosTx {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.messages.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.interchain_accounts.v1.CosmosTx", len)?;
+        if !self.messages.is_empty() {
+            struct_ser.serialize_field("messages", &self.messages)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for CosmosTx {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["messages"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Messages,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "messages" => Ok(GeneratedField::Messages),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = CosmosTx;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.interchain_accounts.v1.CosmosTx")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CosmosTx, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut messages__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Messages => {
+                            if messages__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("messages"));
+                            }
+                            messages__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(CosmosTx {
+                    messages: messages__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.interchain_accounts.v1.CosmosTx",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for InterchainAccount {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.base_account.is_some() {
+            len += 1;
+        }
+        if !self.account_owner.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.interchain_accounts.v1.InterchainAccount",
+            len,
+        )?;
+        if let Some(v) = self.base_account.as_ref() {
+            struct_ser.serialize_field("baseAccount", v)?;
+        }
+        if !self.account_owner.is_empty() {
+            struct_ser.serialize_field("accountOwner", &self.account_owner)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for InterchainAccount {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "base_account",
+            "baseAccount",
+            "account_owner",
+            "accountOwner",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            BaseAccount,
+            AccountOwner,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "baseAccount" | "base_account" => Ok(GeneratedField::BaseAccount),
+                            "accountOwner" | "account_owner" => Ok(GeneratedField::AccountOwner),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = InterchainAccount;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter
+                    .write_str("struct ibc.applications.interchain_accounts.v1.InterchainAccount")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<InterchainAccount, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut base_account__ = None;
+                let mut account_owner__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::BaseAccount => {
+                            if base_account__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("baseAccount"));
+                            }
+                            base_account__ = map_.next_value()?;
+                        }
+                        GeneratedField::AccountOwner => {
+                            if account_owner__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("accountOwner"));
+                            }
+                            account_owner__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(InterchainAccount {
+                    base_account: base_account__,
+                    account_owner: account_owner__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.interchain_accounts.v1.InterchainAccount",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for InterchainAccountPacketData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.r#type != 0 {
+            len += 1;
+        }
+        if !self.data.is_empty() {
+            len += 1;
+        }
+        if !self.memo.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.interchain_accounts.v1.InterchainAccountPacketData",
+            len,
+        )?;
+        if self.r#type != 0 {
+            let v = Type::try_from(self.r#type).map_err(|_| {
+                serde::ser::Error::custom(format!("Invalid variant {}", self.r#type))
+            })?;
+            struct_ser.serialize_field("type", &v)?;
+        }
+        if !self.data.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?;
+        }
+        if !self.memo.is_empty() {
+            struct_ser.serialize_field("memo", &self.memo)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for InterchainAccountPacketData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["type", "data", "memo"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Type,
+            Data,
+            Memo,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "type" => Ok(GeneratedField::Type),
+                            "data" => Ok(GeneratedField::Data),
+                            "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 = InterchainAccountPacketData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str(
+                    "struct ibc.applications.interchain_accounts.v1.InterchainAccountPacketData",
+                )
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<InterchainAccountPacketData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut r#type__ = None;
+                let mut data__ = None;
+                let mut memo__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Type => {
+                            if r#type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("type"));
+                            }
+                            r#type__ = Some(map_.next_value::<Type>()? as i32);
+                        }
+                        GeneratedField::Data => {
+                            if data__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("data"));
+                            }
+                            data__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Memo => {
+                            if memo__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("memo"));
+                            }
+                            memo__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(InterchainAccountPacketData {
+                    r#type: r#type__.unwrap_or_default(),
+                    data: data__.unwrap_or_default(),
+                    memo: memo__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.interchain_accounts.v1.InterchainAccountPacketData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Metadata {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.version.is_empty() {
+            len += 1;
+        }
+        if !self.controller_connection_id.is_empty() {
+            len += 1;
+        }
+        if !self.host_connection_id.is_empty() {
+            len += 1;
+        }
+        if !self.address.is_empty() {
+            len += 1;
+        }
+        if !self.encoding.is_empty() {
+            len += 1;
+        }
+        if !self.tx_type.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.interchain_accounts.v1.Metadata", len)?;
+        if !self.version.is_empty() {
+            struct_ser.serialize_field("version", &self.version)?;
+        }
+        if !self.controller_connection_id.is_empty() {
+            struct_ser.serialize_field("controllerConnectionId", &self.controller_connection_id)?;
+        }
+        if !self.host_connection_id.is_empty() {
+            struct_ser.serialize_field("hostConnectionId", &self.host_connection_id)?;
+        }
+        if !self.address.is_empty() {
+            struct_ser.serialize_field("address", &self.address)?;
+        }
+        if !self.encoding.is_empty() {
+            struct_ser.serialize_field("encoding", &self.encoding)?;
+        }
+        if !self.tx_type.is_empty() {
+            struct_ser.serialize_field("txType", &self.tx_type)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Metadata {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "version",
+            "controller_connection_id",
+            "controllerConnectionId",
+            "host_connection_id",
+            "hostConnectionId",
+            "address",
+            "encoding",
+            "tx_type",
+            "txType",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Version,
+            ControllerConnectionId,
+            HostConnectionId,
+            Address,
+            Encoding,
+            TxType,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "version" => Ok(GeneratedField::Version),
+                            "controllerConnectionId" | "controller_connection_id" => {
+                                Ok(GeneratedField::ControllerConnectionId)
+                            }
+                            "hostConnectionId" | "host_connection_id" => {
+                                Ok(GeneratedField::HostConnectionId)
+                            }
+                            "address" => Ok(GeneratedField::Address),
+                            "encoding" => Ok(GeneratedField::Encoding),
+                            "txType" | "tx_type" => Ok(GeneratedField::TxType),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Metadata;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.interchain_accounts.v1.Metadata")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Metadata, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut version__ = None;
+                let mut controller_connection_id__ = None;
+                let mut host_connection_id__ = None;
+                let mut address__ = None;
+                let mut encoding__ = None;
+                let mut tx_type__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Version => {
+                            if version__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("version"));
+                            }
+                            version__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ControllerConnectionId => {
+                            if controller_connection_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "controllerConnectionId",
+                                ));
+                            }
+                            controller_connection_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::HostConnectionId => {
+                            if host_connection_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("hostConnectionId"));
+                            }
+                            host_connection_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Address => {
+                            if address__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("address"));
+                            }
+                            address__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Encoding => {
+                            if encoding__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("encoding"));
+                            }
+                            encoding__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::TxType => {
+                            if tx_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("txType"));
+                            }
+                            tx_type__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(Metadata {
+                    version: version__.unwrap_or_default(),
+                    controller_connection_id: controller_connection_id__.unwrap_or_default(),
+                    host_connection_id: host_connection_id__.unwrap_or_default(),
+                    address: address__.unwrap_or_default(),
+                    encoding: encoding__.unwrap_or_default(),
+                    tx_type: tx_type__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.interchain_accounts.v1.Metadata",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Type {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::Unspecified => "TYPE_UNSPECIFIED",
+            Self::ExecuteTx => "TYPE_EXECUTE_TX",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Type {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["TYPE_UNSPECIFIED", "TYPE_EXECUTE_TX"];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Type;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                i32::try_from(v)
+                    .ok()
+                    .and_then(|x| x.try_into().ok())
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                i32::try_from(v)
+                    .ok()
+                    .and_then(|x| x.try_into().ok())
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "TYPE_UNSPECIFIED" => Ok(Type::Unspecified),
+                    "TYPE_EXECUTE_TX" => Ok(Type::ExecuteTx),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.transfer.v1.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.transfer.v1.rs
index 528669ed..27b8c899 100644
--- a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.transfer.v1.rs
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.transfer.v1.rs
@@ -1,172 +1,30 @@
-// This file is @generated by prost-build.
-/// MsgTransfer defines a msg to transfer fungible tokens (i.e Coins) between
-/// ICS20 enabled chains. See ICS Spec here:
-/// <https://github.com/cosmos/ibc/tree/master/spec/app/ics-020-fungible-token-transfer#data-structures>
+// @generated
+/// Allocation defines the spend limit for a particular port and channel
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MsgTransfer {
+pub struct Allocation {
     /// the port on which the packet will be sent
     #[prost(string, tag = "1")]
     pub source_port: ::prost::alloc::string::String,
     /// 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
-    #[prost(message, optional, tag = "3")]
-    pub token: ::core::option::Option<super::super::super::super::cosmos::base::v1beta1::Coin>,
-    /// the sender address
-    #[prost(string, tag = "4")]
-    pub sender: ::prost::alloc::string::String,
-    /// the recipient address on the destination chain
-    #[prost(string, tag = "5")]
-    pub receiver: ::prost::alloc::string::String,
-    /// Timeout height relative to the current block height.
-    /// The timeout is disabled when set to 0.
-    #[prost(message, optional, tag = "6")]
-    pub timeout_height: ::core::option::Option<super::super::super::core::client::v1::Height>,
-    /// Timeout timestamp in absolute nanoseconds since unix epoch.
-    /// The timeout is disabled when set to 0.
-    #[prost(uint64, tag = "7")]
-    pub timeout_timestamp: u64,
-    /// optional memo
-    #[prost(string, tag = "8")]
-    pub memo: ::prost::alloc::string::String,
-}
-impl ::prost::Name for MsgTransfer {
-    const NAME: &'static str = "MsgTransfer";
-    const PACKAGE: &'static str = "ibc.applications.transfer.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.transfer.v1.MsgTransfer".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.transfer.v1.MsgTransfer".into()
-    }
+    /// spend limitation on the channel
+    #[prost(message, repeated, tag = "3")]
+    pub spend_limit:
+        ::prost::alloc::vec::Vec<super::super::super::super::cosmos::base::v1beta1::Coin>,
+    /// 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>,
 }
-/// MsgTransferResponse defines the Msg/Transfer response type.
+/// 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, Copy, PartialEq, ::prost::Message)]
-pub struct MsgTransferResponse {
-    /// sequence number of the transfer packet sent
-    #[prost(uint64, tag = "1")]
-    pub sequence: u64,
-}
-impl ::prost::Name for MsgTransferResponse {
-    const NAME: &'static str = "MsgTransferResponse";
-    const PACKAGE: &'static str = "ibc.applications.transfer.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.transfer.v1.MsgTransferResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.transfer.v1.MsgTransferResponse".into()
-    }
-}
-/// Generated client implementations.
-#[cfg(feature = "grpc")]
-pub mod msg_client {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
-    use tonic::codegen::http::Uri;
-    use tonic::codegen::*;
-    /// Msg defines the ibc/transfer Msg service.
-    #[derive(Debug, Clone)]
-    pub struct MsgClient<T> {
-        inner: tonic::client::Grpc<T>,
-    }
-    #[cfg(feature = "grpc-transport")]
-    impl MsgClient<tonic::transport::Channel> {
-        /// Attempt to create a new client by connecting to a given endpoint.
-        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
-        where
-            D: TryInto<tonic::transport::Endpoint>,
-            D::Error: Into<StdError>,
-        {
-            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
-            Ok(Self::new(conn))
-        }
-    }
-    impl<T> MsgClient<T>
-    where
-        T: tonic::client::GrpcService<tonic::body::BoxBody>,
-        T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(inner: T, interceptor: F) -> MsgClient<InterceptedService<T, F>>
-        where
-            F: tonic::service::Interceptor,
-            T::ResponseBody: Default,
-            T: tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
-                Response = http::Response<
-                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
-                >,
-            >,
-            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
-                Into<StdError> + Send + Sync,
-        {
-            MsgClient::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
-        }
-        /// Transfer defines a rpc handler method for MsgTransfer.
-        pub async fn transfer(
-            &mut self,
-            request: impl tonic::IntoRequest<super::MsgTransfer>,
-        ) -> std::result::Result<tonic::Response<super::MsgTransferResponse>, 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.Msg/Transfer");
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.applications.transfer.v1.Msg",
-                "Transfer",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-    }
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct TransferAuthorization {
+    /// port and channel amounts
+    #[prost(message, repeated, tag = "1")]
+    pub allocations: ::prost::alloc::vec::Vec<Allocation>,
 }
 /// DenomTrace contains the base denomination for ICS20 fungible tokens and the
 /// source tracing information path.
@@ -181,22 +39,12 @@ pub struct DenomTrace {
     #[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
 /// parameter for the denomination to false.
 #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Params {
     /// send_enabled enables or disables all cross-chain token transfers from this
     /// chain.
@@ -207,15 +55,16 @@ pub struct Params {
     #[prost(bool, tag = "2")]
     pub receive_enabled: bool,
 }
-impl ::prost::Name for Params {
-    const NAME: &'static str = "Params";
-    const PACKAGE: &'static str = "ibc.applications.transfer.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.transfer.v1.Params".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.transfer.v1.Params".into()
-    }
+/// 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 denom_traces: ::prost::alloc::vec::Vec<DenomTrace>,
+    #[prost(message, optional, tag = "3")]
+    pub params: ::core::option::Option<Params>,
 }
 /// QueryDenomTraceRequest is the request type for the Query/DenomTrace RPC
 /// method
@@ -226,16 +75,6 @@ pub struct QueryDenomTraceRequest {
     #[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)]
@@ -245,16 +84,6 @@ pub struct QueryDenomTraceResponse {
     #[prost(message, optional, tag = "1")]
     pub denom_trace: ::core::option::Option<DenomTrace>,
 }
-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)]
@@ -266,16 +95,6 @@ pub struct QueryDenomTracesRequest {
         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)]
@@ -290,48 +109,18 @@ pub struct QueryDenomTracesResponse {
         super::super::super::super::cosmos::base::query::v1beta1::PageResponse,
     >,
 }
-impl ::prost::Name for QueryDenomTracesResponse {
-    const NAME: &'static str = "QueryDenomTracesResponse";
-    const PACKAGE: &'static str = "ibc.applications.transfer.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.transfer.v1.QueryDenomTracesResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.transfer.v1.QueryDenomTracesResponse".into()
-    }
-}
 /// QueryParamsRequest is the request type for the Query/Params RPC method.
 #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, ::prost::Message)]
 pub struct QueryParamsRequest {}
-impl ::prost::Name for QueryParamsRequest {
-    const NAME: &'static str = "QueryParamsRequest";
-    const PACKAGE: &'static str = "ibc.applications.transfer.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.transfer.v1.QueryParamsRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.transfer.v1.QueryParamsRequest".into()
-    }
-}
 /// QueryParamsResponse is the response type for the Query/Params RPC method.
 #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, ::prost::Message)]
 pub struct QueryParamsResponse {
     /// params defines the parameters of the module.
     #[prost(message, optional, tag = "1")]
     pub params: ::core::option::Option<Params>,
 }
-impl ::prost::Name for QueryParamsResponse {
-    const NAME: &'static str = "QueryParamsResponse";
-    const PACKAGE: &'static str = "ibc.applications.transfer.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.transfer.v1.QueryParamsResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.transfer.v1.QueryParamsResponse".into()
-    }
-}
 /// QueryDenomHashRequest is the request type for the Query/DenomHash RPC
 /// method
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -341,16 +130,6 @@ pub struct QueryDenomHashRequest {
     #[prost(string, tag = "1")]
     pub trace: ::prost::alloc::string::String,
 }
-impl ::prost::Name for QueryDenomHashRequest {
-    const NAME: &'static str = "QueryDenomHashRequest";
-    const PACKAGE: &'static str = "ibc.applications.transfer.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.transfer.v1.QueryDenomHashRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.transfer.v1.QueryDenomHashRequest".into()
-    }
-}
 /// QueryDenomHashResponse is the response type for the Query/DenomHash RPC
 /// method.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -360,16 +139,6 @@ pub struct QueryDenomHashResponse {
     #[prost(string, tag = "1")]
     pub hash: ::prost::alloc::string::String,
 }
-impl ::prost::Name for QueryDenomHashResponse {
-    const NAME: &'static str = "QueryDenomHashResponse";
-    const PACKAGE: &'static str = "ibc.applications.transfer.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.transfer.v1.QueryDenomHashResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.transfer.v1.QueryDenomHashResponse".into()
-    }
-}
 /// QueryEscrowAddressRequest is the request type for the EscrowAddress RPC method.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -381,16 +150,6 @@ pub struct QueryEscrowAddressRequest {
     #[prost(string, tag = "2")]
     pub channel_id: ::prost::alloc::string::String,
 }
-impl ::prost::Name for QueryEscrowAddressRequest {
-    const NAME: &'static str = "QueryEscrowAddressRequest";
-    const PACKAGE: &'static str = "ibc.applications.transfer.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.transfer.v1.QueryEscrowAddressRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.transfer.v1.QueryEscrowAddressRequest".into()
-    }
-}
 /// QueryEscrowAddressResponse is the response type of the EscrowAddress RPC method.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -399,284 +158,47 @@ pub struct QueryEscrowAddressResponse {
     #[prost(string, tag = "1")]
     pub escrow_address: ::prost::alloc::string::String,
 }
-impl ::prost::Name for QueryEscrowAddressResponse {
-    const NAME: &'static str = "QueryEscrowAddressResponse";
-    const PACKAGE: &'static str = "ibc.applications.transfer.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.transfer.v1.QueryEscrowAddressResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.transfer.v1.QueryEscrowAddressResponse".into()
-    }
-}
-/// Generated client implementations.
-#[cfg(feature = "grpc")]
-pub mod query_client {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
-    use tonic::codegen::http::Uri;
-    use tonic::codegen::*;
-    /// Query provides defines the gRPC querier service.
-    #[derive(Debug, Clone)]
-    pub struct QueryClient<T> {
-        inner: tonic::client::Grpc<T>,
-    }
-    #[cfg(feature = "grpc-transport")]
-    impl QueryClient<tonic::transport::Channel> {
-        /// Attempt to create a new client by connecting to a given endpoint.
-        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
-        where
-            D: TryInto<tonic::transport::Endpoint>,
-            D::Error: Into<StdError>,
-        {
-            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
-            Ok(Self::new(conn))
-        }
-    }
-    impl<T> QueryClient<T>
-    where
-        T: tonic::client::GrpcService<tonic::body::BoxBody>,
-        T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(
-            inner: T,
-            interceptor: F,
-        ) -> QueryClient<InterceptedService<T, F>>
-        where
-            F: tonic::service::Interceptor,
-            T::ResponseBody: Default,
-            T: tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
-                Response = http::Response<
-                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
-                >,
-            >,
-            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
-                Into<StdError> + Send + Sync,
-        {
-            QueryClient::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
-        }
-        /// DenomTraces queries all denomination traces.
-        pub async fn denom_traces(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryDenomTracesRequest>,
-        ) -> std::result::Result<tonic::Response<super::QueryDenomTracesResponse>, 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<super::QueryDenomTraceRequest>,
-        ) -> std::result::Result<tonic::Response<super::QueryDenomTraceResponse>, 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,
-            request: impl tonic::IntoRequest<super::QueryParamsRequest>,
-        ) -> std::result::Result<tonic::Response<super::QueryParamsResponse>, 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/Params");
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.applications.transfer.v1.Query",
-                "Params",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// DenomHash queries a denomination hash information.
-        pub async fn denom_hash(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryDenomHashRequest>,
-        ) -> std::result::Result<tonic::Response<super::QueryDenomHashResponse>, 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/DenomHash",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.applications.transfer.v1.Query",
-                "DenomHash",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// EscrowAddress returns the escrow address for a particular port and channel id.
-        pub async fn escrow_address(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryEscrowAddressRequest>,
-        ) -> std::result::Result<tonic::Response<super::QueryEscrowAddressResponse>, 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/EscrowAddress",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.applications.transfer.v1.Query",
-                "EscrowAddress",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-    }
-}
-/// Allocation defines the spend limit for a particular port and channel
+/// MsgTransfer defines a msg to transfer fungible tokens (i.e Coins) between
+/// ICS20 enabled chains. See ICS Spec here:
+/// <https://github.com/cosmos/ibc/tree/master/spec/app/ics-020-fungible-token-transfer#data-structures>
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Allocation {
+pub struct MsgTransfer {
     /// the port on which the packet will be sent
     #[prost(string, tag = "1")]
     pub source_port: ::prost::alloc::string::String,
     /// the channel by which the packet will be sent
     #[prost(string, tag = "2")]
     pub source_channel: ::prost::alloc::string::String,
-    /// spend limitation on the channel
-    #[prost(message, repeated, tag = "3")]
-    pub spend_limit:
-        ::prost::alloc::vec::Vec<super::super::super::super::cosmos::base::v1beta1::Coin>,
-    /// 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>,
-}
-impl ::prost::Name for Allocation {
-    const NAME: &'static str = "Allocation";
-    const PACKAGE: &'static str = "ibc.applications.transfer.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.transfer.v1.Allocation".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.transfer.v1.Allocation".into()
-    }
-}
-/// TransferAuthorization allows the grantee to spend up to spend_limit coins from
-/// 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 TransferAuthorization {
-    /// port and channel amounts
-    #[prost(message, repeated, tag = "1")]
-    pub allocations: ::prost::alloc::vec::Vec<Allocation>,
-}
-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.TransferAuthorization".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.transfer.v1.TransferAuthorization".into()
-    }
+    /// the tokens to be transferred
+    #[prost(message, optional, tag = "3")]
+    pub token: ::core::option::Option<super::super::super::super::cosmos::base::v1beta1::Coin>,
+    /// the sender address
+    #[prost(string, tag = "4")]
+    pub sender: ::prost::alloc::string::String,
+    /// the recipient address on the destination chain
+    #[prost(string, tag = "5")]
+    pub receiver: ::prost::alloc::string::String,
+    /// Timeout height relative to the current block height.
+    /// The timeout is disabled when set to 0.
+    #[prost(message, optional, tag = "6")]
+    pub timeout_height: ::core::option::Option<super::super::super::core::client::v1::Height>,
+    /// Timeout timestamp in absolute nanoseconds since unix epoch.
+    /// The timeout is disabled when set to 0.
+    #[prost(uint64, tag = "7")]
+    pub timeout_timestamp: u64,
+    /// optional memo
+    #[prost(string, tag = "8")]
+    pub memo: ::prost::alloc::string::String,
 }
-/// GenesisState defines the ibc-transfer genesis state
+/// MsgTransferResponse defines the Msg/Transfer response type.
 #[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<DenomTrace>,
-    #[prost(message, optional, tag = "3")]
-    pub params: ::core::option::Option<Params>,
-}
-impl ::prost::Name for GenesisState {
-    const NAME: &'static str = "GenesisState";
-    const PACKAGE: &'static str = "ibc.applications.transfer.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.transfer.v1.GenesisState".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.transfer.v1.GenesisState".into()
-    }
+pub struct MsgTransferResponse {
+    /// sequence number of the transfer packet sent
+    #[prost(uint64, tag = "1")]
+    pub sequence: u64,
 }
+include!("ibc.applications.transfer.v1.serde.rs");
+include!("ibc.applications.transfer.v1.tonic.rs");
+// @@protoc_insertion_point(module)
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.transfer.v1.serde.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.transfer.v1.serde.rs
new file mode 100644
index 00000000..72c791d5
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.transfer.v1.serde.rs
@@ -0,0 +1,2008 @@
+// @generated
+#[cfg(feature = "serde")]
+impl serde::Serialize for Allocation {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.source_port.is_empty() {
+            len += 1;
+        }
+        if !self.source_channel.is_empty() {
+            len += 1;
+        }
+        if !self.spend_limit.is_empty() {
+            len += 1;
+        }
+        if !self.allow_list.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.transfer.v1.Allocation", len)?;
+        if !self.source_port.is_empty() {
+            struct_ser.serialize_field("sourcePort", &self.source_port)?;
+        }
+        if !self.source_channel.is_empty() {
+            struct_ser.serialize_field("sourceChannel", &self.source_channel)?;
+        }
+        if !self.spend_limit.is_empty() {
+            struct_ser.serialize_field("spendLimit", &self.spend_limit)?;
+        }
+        if !self.allow_list.is_empty() {
+            struct_ser.serialize_field("allowList", &self.allow_list)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Allocation {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "source_port",
+            "sourcePort",
+            "source_channel",
+            "sourceChannel",
+            "spend_limit",
+            "spendLimit",
+            "allow_list",
+            "allowList",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            SourcePort,
+            SourceChannel,
+            SpendLimit,
+            AllowList,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "sourcePort" | "source_port" => Ok(GeneratedField::SourcePort),
+                            "sourceChannel" | "source_channel" => Ok(GeneratedField::SourceChannel),
+                            "spendLimit" | "spend_limit" => Ok(GeneratedField::SpendLimit),
+                            "allowList" | "allow_list" => Ok(GeneratedField::AllowList),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Allocation;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.transfer.v1.Allocation")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Allocation, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut source_port__ = None;
+                let mut source_channel__ = None;
+                let mut spend_limit__ = None;
+                let mut allow_list__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::SourcePort => {
+                            if source_port__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sourcePort"));
+                            }
+                            source_port__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::SourceChannel => {
+                            if source_channel__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sourceChannel"));
+                            }
+                            source_channel__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::SpendLimit => {
+                            if spend_limit__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("spendLimit"));
+                            }
+                            spend_limit__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::AllowList => {
+                            if allow_list__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("allowList"));
+                            }
+                            allow_list__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(Allocation {
+                    source_port: source_port__.unwrap_or_default(),
+                    source_channel: source_channel__.unwrap_or_default(),
+                    spend_limit: spend_limit__.unwrap_or_default(),
+                    allow_list: allow_list__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.transfer.v1.Allocation",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for DenomTrace {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.path.is_empty() {
+            len += 1;
+        }
+        if !self.base_denom.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.transfer.v1.DenomTrace", len)?;
+        if !self.path.is_empty() {
+            struct_ser.serialize_field("path", &self.path)?;
+        }
+        if !self.base_denom.is_empty() {
+            struct_ser.serialize_field("baseDenom", &self.base_denom)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for DenomTrace {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["path", "base_denom", "baseDenom"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Path,
+            BaseDenom,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "path" => Ok(GeneratedField::Path),
+                            "baseDenom" | "base_denom" => Ok(GeneratedField::BaseDenom),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = DenomTrace;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.transfer.v1.DenomTrace")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DenomTrace, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut path__ = None;
+                let mut base_denom__ = 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::BaseDenom => {
+                            if base_denom__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("baseDenom"));
+                            }
+                            base_denom__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(DenomTrace {
+                    path: path__.unwrap_or_default(),
+                    base_denom: base_denom__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.transfer.v1.DenomTrace",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for GenesisState {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.denom_traces.is_empty() {
+            len += 1;
+        }
+        if self.params.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.transfer.v1.GenesisState", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.denom_traces.is_empty() {
+            struct_ser.serialize_field("denomTraces", &self.denom_traces)?;
+        }
+        if let Some(v) = self.params.as_ref() {
+            struct_ser.serialize_field("params", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for GenesisState {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["port_id", "portId", "denom_traces", "denomTraces", "params"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            DenomTraces,
+            Params,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "denomTraces" | "denom_traces" => Ok(GeneratedField::DenomTraces),
+                            "params" => Ok(GeneratedField::Params),
+                            _ => 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 std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.transfer.v1.GenesisState")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GenesisState, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut denom_traces__ = None;
+                let mut params__ = 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::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()?;
+                        }
+                    }
+                }
+                Ok(GenesisState {
+                    port_id: port_id__.unwrap_or_default(),
+                    denom_traces: denom_traces__.unwrap_or_default(),
+                    params: params__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.transfer.v1.GenesisState",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgTransfer {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.source_port.is_empty() {
+            len += 1;
+        }
+        if !self.source_channel.is_empty() {
+            len += 1;
+        }
+        if self.token.is_some() {
+            len += 1;
+        }
+        if !self.sender.is_empty() {
+            len += 1;
+        }
+        if !self.receiver.is_empty() {
+            len += 1;
+        }
+        if self.timeout_height.is_some() {
+            len += 1;
+        }
+        if self.timeout_timestamp != 0 {
+            len += 1;
+        }
+        if !self.memo.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.transfer.v1.MsgTransfer", len)?;
+        if !self.source_port.is_empty() {
+            struct_ser.serialize_field("sourcePort", &self.source_port)?;
+        }
+        if !self.source_channel.is_empty() {
+            struct_ser.serialize_field("sourceChannel", &self.source_channel)?;
+        }
+        if let Some(v) = self.token.as_ref() {
+            struct_ser.serialize_field("token", v)?;
+        }
+        if !self.sender.is_empty() {
+            struct_ser.serialize_field("sender", &self.sender)?;
+        }
+        if !self.receiver.is_empty() {
+            struct_ser.serialize_field("receiver", &self.receiver)?;
+        }
+        if let Some(v) = self.timeout_height.as_ref() {
+            struct_ser.serialize_field("timeoutHeight", v)?;
+        }
+        if self.timeout_timestamp != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "timeoutTimestamp",
+                ToString::to_string(&self.timeout_timestamp).as_str(),
+            )?;
+        }
+        if !self.memo.is_empty() {
+            struct_ser.serialize_field("memo", &self.memo)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgTransfer {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "source_port",
+            "sourcePort",
+            "source_channel",
+            "sourceChannel",
+            "token",
+            "sender",
+            "receiver",
+            "timeout_height",
+            "timeoutHeight",
+            "timeout_timestamp",
+            "timeoutTimestamp",
+            "memo",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            SourcePort,
+            SourceChannel,
+            Token,
+            Sender,
+            Receiver,
+            TimeoutHeight,
+            TimeoutTimestamp,
+            Memo,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "sourcePort" | "source_port" => Ok(GeneratedField::SourcePort),
+                            "sourceChannel" | "source_channel" => Ok(GeneratedField::SourceChannel),
+                            "token" => Ok(GeneratedField::Token),
+                            "sender" => Ok(GeneratedField::Sender),
+                            "receiver" => Ok(GeneratedField::Receiver),
+                            "timeoutHeight" | "timeout_height" => Ok(GeneratedField::TimeoutHeight),
+                            "timeoutTimestamp" | "timeout_timestamp" => {
+                                Ok(GeneratedField::TimeoutTimestamp)
+                            }
+                            "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 = MsgTransfer;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.transfer.v1.MsgTransfer")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MsgTransfer, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut source_port__ = None;
+                let mut source_channel__ = None;
+                let mut token__ = None;
+                let mut sender__ = None;
+                let mut receiver__ = None;
+                let mut timeout_height__ = None;
+                let mut timeout_timestamp__ = None;
+                let mut memo__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::SourcePort => {
+                            if source_port__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sourcePort"));
+                            }
+                            source_port__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::SourceChannel => {
+                            if source_channel__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sourceChannel"));
+                            }
+                            source_channel__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Token => {
+                            if token__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("token"));
+                            }
+                            token__ = 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::TimeoutHeight => {
+                            if timeout_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timeoutHeight"));
+                            }
+                            timeout_height__ = map_.next_value()?;
+                        }
+                        GeneratedField::TimeoutTimestamp => {
+                            if timeout_timestamp__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timeoutTimestamp"));
+                            }
+                            timeout_timestamp__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Memo => {
+                            if memo__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("memo"));
+                            }
+                            memo__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgTransfer {
+                    source_port: source_port__.unwrap_or_default(),
+                    source_channel: source_channel__.unwrap_or_default(),
+                    token: token__,
+                    sender: sender__.unwrap_or_default(),
+                    receiver: receiver__.unwrap_or_default(),
+                    timeout_height: timeout_height__,
+                    timeout_timestamp: timeout_timestamp__.unwrap_or_default(),
+                    memo: memo__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.transfer.v1.MsgTransfer",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgTransferResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.sequence != 0 {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.transfer.v1.MsgTransferResponse", len)?;
+        if self.sequence != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("sequence", ToString::to_string(&self.sequence).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgTransferResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["sequence"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Sequence,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "sequence" => Ok(GeneratedField::Sequence),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgTransferResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.transfer.v1.MsgTransferResponse")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MsgTransferResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut sequence__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Sequence => {
+                            if sequence__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sequence"));
+                            }
+                            sequence__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(MsgTransferResponse {
+                    sequence: sequence__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.transfer.v1.MsgTransferResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Params {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.send_enabled {
+            len += 1;
+        }
+        if self.receive_enabled {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.transfer.v1.Params", len)?;
+        if self.send_enabled {
+            struct_ser.serialize_field("sendEnabled", &self.send_enabled)?;
+        }
+        if self.receive_enabled {
+            struct_ser.serialize_field("receiveEnabled", &self.receive_enabled)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Params {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "send_enabled",
+            "sendEnabled",
+            "receive_enabled",
+            "receiveEnabled",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            SendEnabled,
+            ReceiveEnabled,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "sendEnabled" | "send_enabled" => Ok(GeneratedField::SendEnabled),
+                            "receiveEnabled" | "receive_enabled" => {
+                                Ok(GeneratedField::ReceiveEnabled)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Params;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.transfer.v1.Params")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Params, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut send_enabled__ = None;
+                let mut receive_enabled__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::SendEnabled => {
+                            if send_enabled__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sendEnabled"));
+                            }
+                            send_enabled__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ReceiveEnabled => {
+                            if receive_enabled__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("receiveEnabled"));
+                            }
+                            receive_enabled__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(Params {
+                    send_enabled: send_enabled__.unwrap_or_default(),
+                    receive_enabled: receive_enabled__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.transfer.v1.Params",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryDenomHashRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.trace.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.applications.transfer.v1.QueryDenomHashRequest", len)?;
+        if !self.trace.is_empty() {
+            struct_ser.serialize_field("trace", &self.trace)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryDenomHashRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["trace"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Trace,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "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 = QueryDenomHashRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.transfer.v1.QueryDenomHashRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryDenomHashRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut trace__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Trace => {
+                            if trace__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("trace"));
+                            }
+                            trace__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryDenomHashRequest {
+                    trace: trace__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.transfer.v1.QueryDenomHashRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryDenomHashResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.hash.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.applications.transfer.v1.QueryDenomHashResponse", len)?;
+        if !self.hash.is_empty() {
+            struct_ser.serialize_field("hash", &self.hash)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryDenomHashResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["hash"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Hash,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    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 = QueryDenomHashResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.transfer.v1.QueryDenomHashResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryDenomHashResponse, V::Error>
+            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(QueryDenomHashResponse {
+                    hash: hash__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.transfer.v1.QueryDenomHashResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryDenomTraceRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.hash.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.applications.transfer.v1.QueryDenomTraceRequest", len)?;
+        if !self.hash.is_empty() {
+            struct_ser.serialize_field("hash", &self.hash)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryDenomTraceRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["hash"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Hash,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    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 std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.transfer.v1.QueryDenomTraceRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryDenomTraceRequest, V::Error>
+            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,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryDenomTraceResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.denom_trace.is_some() {
+            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()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryDenomTraceResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["denom_trace", "denomTrace"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            DenomTrace,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    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 std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.transfer.v1.QueryDenomTraceResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryDenomTraceResponse, V::Error>
+            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,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryDenomTracesRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.pagination.is_some() {
+            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()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryDenomTracesRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["pagination"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Pagination,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    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 std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.transfer.v1.QueryDenomTracesRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryDenomTracesRequest, V::Error>
+            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,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryDenomTracesResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.denom_traces.is_empty() {
+            len += 1;
+        }
+        if self.pagination.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.applications.transfer.v1.QueryDenomTracesResponse", len)?;
+        if !self.denom_traces.is_empty() {
+            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()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryDenomTracesResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["denom_traces", "denomTraces", "pagination"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            DenomTraces,
+            Pagination,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    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 std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.transfer.v1.QueryDenomTracesResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryDenomTracesResponse, V::Error>
+            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,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryEscrowAddressRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.transfer.v1.QueryEscrowAddressRequest",
+            len,
+        )?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryEscrowAddressRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["port_id", "portId", "channel_id", "channelId"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryEscrowAddressRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.transfer.v1.QueryEscrowAddressRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryEscrowAddressRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryEscrowAddressRequest {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.transfer.v1.QueryEscrowAddressRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryEscrowAddressResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.escrow_address.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.applications.transfer.v1.QueryEscrowAddressResponse",
+            len,
+        )?;
+        if !self.escrow_address.is_empty() {
+            struct_ser.serialize_field("escrowAddress", &self.escrow_address)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryEscrowAddressResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["escrow_address", "escrowAddress"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            EscrowAddress,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "escrowAddress" | "escrow_address" => Ok(GeneratedField::EscrowAddress),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryEscrowAddressResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter
+                    .write_str("struct ibc.applications.transfer.v1.QueryEscrowAddressResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryEscrowAddressResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut escrow_address__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::EscrowAddress => {
+                            if escrow_address__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("escrowAddress"));
+                            }
+                            escrow_address__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryEscrowAddressResponse {
+                    escrow_address: escrow_address__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.transfer.v1.QueryEscrowAddressResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryParamsRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser =
+            serializer.serialize_struct("ibc.applications.transfer.v1.QueryParamsRequest", len)?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryParamsRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryParamsRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.transfer.v1.QueryParamsRequest")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<QueryParamsRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(QueryParamsRequest {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.transfer.v1.QueryParamsRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryParamsResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.params.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.applications.transfer.v1.QueryParamsResponse", len)?;
+        if let Some(v) = self.params.as_ref() {
+            struct_ser.serialize_field("params", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryParamsResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["params"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Params,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "params" => Ok(GeneratedField::Params),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryParamsResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.transfer.v1.QueryParamsResponse")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<QueryParamsResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut params__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Params => {
+                            if params__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("params"));
+                            }
+                            params__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryParamsResponse { params: params__ })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.transfer.v1.QueryParamsResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for TransferAuthorization {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.allocations.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.applications.transfer.v1.TransferAuthorization", len)?;
+        if !self.allocations.is_empty() {
+            struct_ser.serialize_field("allocations", &self.allocations)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for TransferAuthorization {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["allocations"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Allocations,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "allocations" => Ok(GeneratedField::Allocations),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = TransferAuthorization;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.transfer.v1.TransferAuthorization")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<TransferAuthorization, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut allocations__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Allocations => {
+                            if allocations__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("allocations"));
+                            }
+                            allocations__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(TransferAuthorization {
+                    allocations: allocations__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.applications.transfer.v1.TransferAuthorization",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.transfer.v1.tonic.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.transfer.v1.tonic.rs
new file mode 100644
index 00000000..aac8b0b1
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.transfer.v1.tonic.rs
@@ -0,0 +1,802 @@
+// @generated
+/// Generated client implementations.
+#[cfg(feature = "grpc")]
+pub mod query_client {
+    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
+    use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
+    #[derive(Debug, Clone)]
+    pub struct QueryClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    #[cfg(feature = "grpc-transport")]
+    impl QueryClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> QueryClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> QueryClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
+                Into<StdError> + Send + Sync,
+        {
+            QueryClient::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
+        }
+        pub async fn denom_traces(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryDenomTracesRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryDenomTracesResponse>, 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
+        }
+        pub async fn denom_trace(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryDenomTraceRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryDenomTraceResponse>, 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
+        }
+        pub async fn params(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryParamsRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryParamsResponse>, 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/Params");
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.applications.transfer.v1.Query",
+                "Params",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn denom_hash(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryDenomHashRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryDenomHashResponse>, 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/DenomHash",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.applications.transfer.v1.Query",
+                "DenomHash",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn escrow_address(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryEscrowAddressRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryEscrowAddressResponse>, 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/EscrowAddress",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.applications.transfer.v1.Query",
+                "EscrowAddress",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+#[cfg(feature = "grpc")]
+pub mod query_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 QueryServer.
+    #[async_trait]
+    pub trait Query: Send + Sync + 'static {
+        async fn denom_traces(
+            &self,
+            request: tonic::Request<super::QueryDenomTracesRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryDenomTracesResponse>, tonic::Status>;
+        async fn denom_trace(
+            &self,
+            request: tonic::Request<super::QueryDenomTraceRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryDenomTraceResponse>, tonic::Status>;
+        async fn params(
+            &self,
+            request: tonic::Request<super::QueryParamsRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryParamsResponse>, tonic::Status>;
+        async fn denom_hash(
+            &self,
+            request: tonic::Request<super::QueryDenomHashRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryDenomHashResponse>, tonic::Status>;
+        async fn escrow_address(
+            &self,
+            request: tonic::Request<super::QueryEscrowAddressRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryEscrowAddressResponse>, tonic::Status>;
+    }
+    #[derive(Debug)]
+    pub struct QueryServer<T: Query> {
+        inner: _Inner<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    struct _Inner<T>(Arc<T>);
+    impl<T: Query> QueryServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            let inner = _Inner(inner);
+            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<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
+        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<T, B> tonic::codegen::Service<http::Request<B>> for QueryServer<T>
+    where
+        T: Query,
+        B: Body + Send + 'static,
+        B::Error: Into<StdError> + Send + 'static,
+    {
+        type Response = http::Response<tonic::body::BoxBody>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            let inner = self.inner.clone();
+            match req.uri().path() {
+                "/ibc.applications.transfer.v1.Query/DenomTraces" => {
+                    #[allow(non_camel_case_types)]
+                    struct DenomTracesSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryDenomTracesRequest> for DenomTracesSvc<T> {
+                        type Response = super::QueryDenomTracesResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryDenomTracesRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).denom_traces(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 = 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<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryDenomTraceRequest> for DenomTraceSvc<T> {
+                        type Response = super::QueryDenomTraceResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryDenomTraceRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).denom_trace(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 = 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<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryParamsRequest> for ParamsSvc<T> {
+                        type Response = super::QueryParamsResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryParamsRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).params(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 = ParamsSvc(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/DenomHash" => {
+                    #[allow(non_camel_case_types)]
+                    struct DenomHashSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryDenomHashRequest> for DenomHashSvc<T> {
+                        type Response = super::QueryDenomHashResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryDenomHashRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).denom_hash(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 = DenomHashSvc(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/EscrowAddress" => {
+                    #[allow(non_camel_case_types)]
+                    struct EscrowAddressSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryEscrowAddressRequest>
+                        for EscrowAddressSvc<T>
+                    {
+                        type Response = super::QueryEscrowAddressResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryEscrowAddressRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).escrow_address(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 = EscrowAddressSvc(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", "12")
+                        .header("content-type", "application/grpc")
+                        .body(empty_body())
+                        .unwrap())
+                }),
+            }
+        }
+    }
+    impl<T: Query> Clone for QueryServer<T> {
+        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<T: Query> Clone for _Inner<T> {
+        fn clone(&self) -> Self {
+            Self(Arc::clone(&self.0))
+        }
+    }
+    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "{:?}", self.0)
+        }
+    }
+    impl<T: Query> tonic::server::NamedService for QueryServer<T> {
+        const NAME: &'static str = "ibc.applications.transfer.v1.Query";
+    }
+}
+/// Generated client implementations.
+#[cfg(feature = "grpc")]
+pub mod msg_client {
+    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
+    use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
+    #[derive(Debug, Clone)]
+    pub struct MsgClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    #[cfg(feature = "grpc-transport")]
+    impl MsgClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> MsgClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(inner: T, interceptor: F) -> MsgClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
+                Into<StdError> + Send + Sync,
+        {
+            MsgClient::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
+        }
+        pub async fn transfer(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgTransfer>,
+        ) -> std::result::Result<tonic::Response<super::MsgTransferResponse>, 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.Msg/Transfer");
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.applications.transfer.v1.Msg",
+                "Transfer",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+#[cfg(feature = "grpc")]
+pub mod msg_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 MsgServer.
+    #[async_trait]
+    pub trait Msg: Send + Sync + 'static {
+        async fn transfer(
+            &self,
+            request: tonic::Request<super::MsgTransfer>,
+        ) -> std::result::Result<tonic::Response<super::MsgTransferResponse>, tonic::Status>;
+    }
+    #[derive(Debug)]
+    pub struct MsgServer<T: Msg> {
+        inner: _Inner<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    struct _Inner<T>(Arc<T>);
+    impl<T: Msg> MsgServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            let inner = _Inner(inner);
+            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<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
+        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<T, B> tonic::codegen::Service<http::Request<B>> for MsgServer<T>
+    where
+        T: Msg,
+        B: Body + Send + 'static,
+        B::Error: Into<StdError> + Send + 'static,
+    {
+        type Response = http::Response<tonic::body::BoxBody>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            let inner = self.inner.clone();
+            match req.uri().path() {
+                "/ibc.applications.transfer.v1.Msg/Transfer" => {
+                    #[allow(non_camel_case_types)]
+                    struct TransferSvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgTransfer> for TransferSvc<T> {
+                        type Response = super::MsgTransferResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgTransfer>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).transfer(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 = TransferSvc(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", "12")
+                        .header("content-type", "application/grpc")
+                        .body(empty_body())
+                        .unwrap())
+                }),
+            }
+        }
+    }
+    impl<T: Msg> Clone for MsgServer<T> {
+        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<T: Msg> Clone for _Inner<T> {
+        fn clone(&self) -> Self {
+            Self(Arc::clone(&self.0))
+        }
+    }
+    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "{:?}", self.0)
+        }
+    }
+    impl<T: Msg> tonic::server::NamedService for MsgServer<T> {
+        const NAME: &'static str = "ibc.applications.transfer.v1.Msg";
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.transfer.v2.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.transfer.v2.rs
index a479baef..b707b2d1 100644
--- a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.transfer.v2.rs
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.transfer.v2.rs
@@ -1,4 +1,4 @@
-// This file is @generated by prost-build.
+// @generated
 /// FungibleTokenPacketData defines a struct for the packet payload
 /// See FungibleTokenPacketData spec:
 /// <https://github.com/cosmos/ibc/tree/master/spec/app/ics-020-fungible-token-transfer#data-structures>
@@ -21,13 +21,5 @@ pub struct FungibleTokenPacketData {
     #[prost(string, tag = "5")]
     pub memo: ::prost::alloc::string::String,
 }
-impl ::prost::Name for FungibleTokenPacketData {
-    const NAME: &'static str = "FungibleTokenPacketData";
-    const PACKAGE: &'static str = "ibc.applications.transfer.v2";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.applications.transfer.v2.FungibleTokenPacketData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.applications.transfer.v2.FungibleTokenPacketData".into()
-    }
-}
+include!("ibc.applications.transfer.v2.serde.rs");
+// @@protoc_insertion_point(module)
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.transfer.v2.serde.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.transfer.v2.serde.rs
new file mode 100644
index 00000000..4fde4588
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.applications.transfer.v2.serde.rs
@@ -0,0 +1,168 @@
+// @generated
+#[cfg(feature = "serde")]
+impl serde::Serialize for FungibleTokenPacketData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.denom.is_empty() {
+            len += 1;
+        }
+        if !self.amount.is_empty() {
+            len += 1;
+        }
+        if !self.sender.is_empty() {
+            len += 1;
+        }
+        if !self.receiver.is_empty() {
+            len += 1;
+        }
+        if !self.memo.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.applications.transfer.v2.FungibleTokenPacketData", len)?;
+        if !self.denom.is_empty() {
+            struct_ser.serialize_field("denom", &self.denom)?;
+        }
+        if !self.amount.is_empty() {
+            struct_ser.serialize_field("amount", &self.amount)?;
+        }
+        if !self.sender.is_empty() {
+            struct_ser.serialize_field("sender", &self.sender)?;
+        }
+        if !self.receiver.is_empty() {
+            struct_ser.serialize_field("receiver", &self.receiver)?;
+        }
+        if !self.memo.is_empty() {
+            struct_ser.serialize_field("memo", &self.memo)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for FungibleTokenPacketData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["denom", "amount", "sender", "receiver", "memo"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Denom,
+            Amount,
+            Sender,
+            Receiver,
+            Memo,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "denom" => Ok(GeneratedField::Denom),
+                            "amount" => Ok(GeneratedField::Amount),
+                            "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 = FungibleTokenPacketData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.applications.transfer.v2.FungibleTokenPacketData")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<FungibleTokenPacketData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut denom__ = None;
+                let mut amount__ = None;
+                let mut sender__ = None;
+                let mut receiver__ = None;
+                let mut memo__ = 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::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(FungibleTokenPacketData {
+                    denom: denom__.unwrap_or_default(),
+                    amount: amount__.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.FungibleTokenPacketData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.channel.v1.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.channel.v1.rs
index e77e6128..ebf40c5e 100644
--- a/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.channel.v1.rs
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.channel.v1.rs
@@ -1,4 +1,4 @@
-// This file is @generated by prost-build.
+// @generated
 /// Channel defines pipeline for exactly-once packet delivery between specific
 /// modules on separate blockchains, which has at least one end capable of
 /// sending packets and one end capable of receiving packets.
@@ -22,16 +22,6 @@ pub struct Channel {
     #[prost(string, tag = "5")]
     pub version: ::prost::alloc::string::String,
 }
-impl ::prost::Name for Channel {
-    const NAME: &'static str = "Channel";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.Channel".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.Channel".into()
-    }
-}
 /// IdentifiedChannel defines a channel with additional port and channel
 /// identifier fields.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -60,16 +50,6 @@ pub struct IdentifiedChannel {
     #[prost(string, tag = "7")]
     pub channel_id: ::prost::alloc::string::String,
 }
-impl ::prost::Name for IdentifiedChannel {
-    const NAME: &'static str = "IdentifiedChannel";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.IdentifiedChannel".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.IdentifiedChannel".into()
-    }
-}
 /// Counterparty defines a channel end counterparty
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -81,16 +61,6 @@ pub struct Counterparty {
     #[prost(string, tag = "2")]
     pub channel_id: ::prost::alloc::string::String,
 }
-impl ::prost::Name for Counterparty {
-    const NAME: &'static str = "Counterparty";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.Counterparty".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.Counterparty".into()
-    }
-}
 /// Packet defines a type that carries data across different chains through IBC
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -122,16 +92,6 @@ pub struct Packet {
     #[prost(uint64, tag = "8")]
     pub timeout_timestamp: u64,
 }
-impl ::prost::Name for Packet {
-    const NAME: &'static str = "Packet";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.Packet".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.Packet".into()
-    }
-}
 /// PacketState defines the generic type necessary to retrieve and store
 /// packet commitments, acknowledgements, and receipts.
 /// Caller is responsible for knowing the context necessary to interpret this
@@ -152,16 +112,6 @@ pub struct PacketState {
     #[prost(bytes = "vec", tag = "4")]
     pub data: ::prost::alloc::vec::Vec<u8>,
 }
-impl ::prost::Name for PacketState {
-    const NAME: &'static str = "PacketState";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.PacketState".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.PacketState".into()
-    }
-}
 /// PacketId is an identifer for a unique Packet
 /// Source chains refer to packets by source port/channel
 /// Destination chains refer to packets by destination port/channel
@@ -178,16 +128,6 @@ pub struct PacketId {
     #[prost(uint64, tag = "3")]
     pub sequence: u64,
 }
-impl ::prost::Name for PacketId {
-    const NAME: &'static str = "PacketId";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.PacketId".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.PacketId".into()
-    }
-}
 /// Acknowledgement is the recommended acknowledgement format to be used by
 /// app-specific protocols.
 /// NOTE: The field numbers 21 and 22 were explicitly chosen to avoid accidental
@@ -214,16 +154,6 @@ pub mod acknowledgement {
         Error(::prost::alloc::string::String),
     }
 }
-impl ::prost::Name for Acknowledgement {
-    const NAME: &'static str = "Acknowledgement";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.Acknowledgement".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.Acknowledgement".into()
-    }
-}
 /// State defines if a channel is in one of the following states:
 /// CLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
@@ -302,1031 +232,202 @@ impl Order {
         }
     }
 }
-/// MsgChannelOpenInit defines an sdk.Msg to initialize a channel handshake. It
-/// is called by a relayer on Chain A.
+/// GenesisState defines the ibc channel submodule's genesis state.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MsgChannelOpenInit {
-    #[prost(string, tag = "1")]
-    pub port_id: ::prost::alloc::string::String,
-    #[prost(message, optional, tag = "2")]
-    pub channel: ::core::option::Option<Channel>,
-    #[prost(string, tag = "3")]
-    pub signer: ::prost::alloc::string::String,
-}
-impl ::prost::Name for MsgChannelOpenInit {
-    const NAME: &'static str = "MsgChannelOpenInit";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.MsgChannelOpenInit".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.MsgChannelOpenInit".into()
-    }
+pub struct GenesisState {
+    #[prost(message, repeated, tag = "1")]
+    pub channels: ::prost::alloc::vec::Vec<IdentifiedChannel>,
+    #[prost(message, repeated, tag = "2")]
+    pub acknowledgements: ::prost::alloc::vec::Vec<PacketState>,
+    #[prost(message, repeated, tag = "3")]
+    pub commitments: ::prost::alloc::vec::Vec<PacketState>,
+    #[prost(message, repeated, tag = "4")]
+    pub receipts: ::prost::alloc::vec::Vec<PacketState>,
+    #[prost(message, repeated, tag = "5")]
+    pub send_sequences: ::prost::alloc::vec::Vec<PacketSequence>,
+    #[prost(message, repeated, tag = "6")]
+    pub recv_sequences: ::prost::alloc::vec::Vec<PacketSequence>,
+    #[prost(message, repeated, tag = "7")]
+    pub ack_sequences: ::prost::alloc::vec::Vec<PacketSequence>,
+    /// the sequence for the next generated channel identifier
+    #[prost(uint64, tag = "8")]
+    pub next_channel_sequence: u64,
 }
-/// MsgChannelOpenInitResponse defines the Msg/ChannelOpenInit response type.
+/// PacketSequence defines the genesis type necessary to retrieve and store
+/// next send and receive sequences.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MsgChannelOpenInitResponse {
+pub struct PacketSequence {
     #[prost(string, tag = "1")]
-    pub channel_id: ::prost::alloc::string::String,
+    pub port_id: ::prost::alloc::string::String,
     #[prost(string, tag = "2")]
-    pub version: ::prost::alloc::string::String,
-}
-impl ::prost::Name for MsgChannelOpenInitResponse {
-    const NAME: &'static str = "MsgChannelOpenInitResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.MsgChannelOpenInitResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.MsgChannelOpenInitResponse".into()
-    }
+    pub channel_id: ::prost::alloc::string::String,
+    #[prost(uint64, tag = "3")]
+    pub sequence: u64,
 }
-/// MsgChannelOpenInit defines a msg sent by a Relayer to try to open a channel
-/// on Chain B. The version field within the Channel field has been deprecated. Its
-/// value will be ignored by core IBC.
+/// QueryChannelRequest is the request type for the Query/Channel RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MsgChannelOpenTry {
+pub struct QueryChannelRequest {
+    /// port unique identifier
     #[prost(string, tag = "1")]
     pub port_id: ::prost::alloc::string::String,
-    /// Deprecated: this field is unused. Crossing hello's are no longer supported in core IBC.
-    #[deprecated]
+    /// channel unique identifier
     #[prost(string, tag = "2")]
-    pub previous_channel_id: ::prost::alloc::string::String,
-    /// NOTE: the version field within the channel has been deprecated. Its value will be ignored by core IBC.
-    #[prost(message, optional, tag = "3")]
+    pub channel_id: ::prost::alloc::string::String,
+}
+/// QueryChannelResponse is the response type for the Query/Channel RPC method.
+/// Besides the Channel end, it includes a proof and the height from which the
+/// proof was retrieved.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryChannelResponse {
+    /// channel associated with the request identifiers
+    #[prost(message, optional, tag = "1")]
     pub channel: ::core::option::Option<Channel>,
-    #[prost(string, tag = "4")]
-    pub counterparty_version: ::prost::alloc::string::String,
-    #[prost(bytes = "vec", tag = "5")]
-    pub proof_init: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, optional, tag = "6")]
+    /// merkle proof of existence
+    #[prost(bytes = "vec", tag = "2")]
+    pub proof: ::prost::alloc::vec::Vec<u8>,
+    /// height at which the proof was retrieved
+    #[prost(message, optional, tag = "3")]
     pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
-    #[prost(string, tag = "7")]
-    pub signer: ::prost::alloc::string::String,
 }
-impl ::prost::Name for MsgChannelOpenTry {
-    const NAME: &'static str = "MsgChannelOpenTry";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.MsgChannelOpenTry".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.MsgChannelOpenTry".into()
-    }
+/// QueryChannelsRequest is the request type for the Query/Channels RPC method
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryChannelsRequest {
+    /// pagination request
+    #[prost(message, optional, tag = "1")]
+    pub pagination: ::core::option::Option<
+        super::super::super::super::cosmos::base::query::v1beta1::PageRequest,
+    >,
 }
-/// MsgChannelOpenTryResponse defines the Msg/ChannelOpenTry response type.
+/// QueryChannelsResponse is the response type for the Query/Channels RPC method.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MsgChannelOpenTryResponse {
+pub struct QueryChannelsResponse {
+    /// list of stored channels of the chain.
+    #[prost(message, repeated, tag = "1")]
+    pub channels: ::prost::alloc::vec::Vec<IdentifiedChannel>,
+    /// pagination response
+    #[prost(message, optional, tag = "2")]
+    pub pagination: ::core::option::Option<
+        super::super::super::super::cosmos::base::query::v1beta1::PageResponse,
+    >,
+    /// query block height
+    #[prost(message, optional, tag = "3")]
+    pub height: ::core::option::Option<super::super::client::v1::Height>,
+}
+/// QueryConnectionChannelsRequest is the request type for the
+/// Query/QueryConnectionChannels RPC method
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryConnectionChannelsRequest {
+    /// connection unique identifier
     #[prost(string, tag = "1")]
-    pub version: ::prost::alloc::string::String,
+    pub connection: ::prost::alloc::string::String,
+    /// pagination request
+    #[prost(message, optional, tag = "2")]
+    pub pagination: ::core::option::Option<
+        super::super::super::super::cosmos::base::query::v1beta1::PageRequest,
+    >,
 }
-impl ::prost::Name for MsgChannelOpenTryResponse {
-    const NAME: &'static str = "MsgChannelOpenTryResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.MsgChannelOpenTryResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.MsgChannelOpenTryResponse".into()
-    }
+/// QueryConnectionChannelsResponse is the Response type for the
+/// Query/QueryConnectionChannels RPC method
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryConnectionChannelsResponse {
+    /// list of channels associated with a connection.
+    #[prost(message, repeated, tag = "1")]
+    pub channels: ::prost::alloc::vec::Vec<IdentifiedChannel>,
+    /// pagination response
+    #[prost(message, optional, tag = "2")]
+    pub pagination: ::core::option::Option<
+        super::super::super::super::cosmos::base::query::v1beta1::PageResponse,
+    >,
+    /// query block height
+    #[prost(message, optional, tag = "3")]
+    pub height: ::core::option::Option<super::super::client::v1::Height>,
 }
-/// MsgChannelOpenAck defines a msg sent by a Relayer to Chain A to acknowledge
-/// the change of channel state to TRYOPEN on Chain B.
+/// QueryChannelClientStateRequest is the request type for the Query/ClientState
+/// RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MsgChannelOpenAck {
+pub struct QueryChannelClientStateRequest {
+    /// port unique identifier
     #[prost(string, tag = "1")]
     pub port_id: ::prost::alloc::string::String,
+    /// channel unique identifier
     #[prost(string, tag = "2")]
     pub channel_id: ::prost::alloc::string::String,
-    #[prost(string, tag = "3")]
-    pub counterparty_channel_id: ::prost::alloc::string::String,
-    #[prost(string, tag = "4")]
-    pub counterparty_version: ::prost::alloc::string::String,
-    #[prost(bytes = "vec", tag = "5")]
-    pub proof_try: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, optional, tag = "6")]
-    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
-    #[prost(string, tag = "7")]
-    pub signer: ::prost::alloc::string::String,
-}
-impl ::prost::Name for MsgChannelOpenAck {
-    const NAME: &'static str = "MsgChannelOpenAck";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.MsgChannelOpenAck".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.MsgChannelOpenAck".into()
-    }
 }
-/// MsgChannelOpenAckResponse defines the Msg/ChannelOpenAck response type.
+/// QueryChannelClientStateResponse is the Response type for the
+/// Query/QueryChannelClientState RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct MsgChannelOpenAckResponse {}
-impl ::prost::Name for MsgChannelOpenAckResponse {
-    const NAME: &'static str = "MsgChannelOpenAckResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.MsgChannelOpenAckResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.MsgChannelOpenAckResponse".into()
-    }
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryChannelClientStateResponse {
+    /// client state associated with the channel
+    #[prost(message, optional, tag = "1")]
+    pub identified_client_state:
+        ::core::option::Option<super::super::client::v1::IdentifiedClientState>,
+    /// merkle proof of existence
+    #[prost(bytes = "vec", tag = "2")]
+    pub proof: ::prost::alloc::vec::Vec<u8>,
+    /// height at which the proof was retrieved
+    #[prost(message, optional, tag = "3")]
+    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
 }
-/// MsgChannelOpenConfirm defines a msg sent by a Relayer to Chain B to
-/// acknowledge the change of channel state to OPEN on Chain A.
+/// QueryChannelConsensusStateRequest is the request type for the
+/// Query/ConsensusState RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MsgChannelOpenConfirm {
+pub struct QueryChannelConsensusStateRequest {
+    /// port unique identifier
     #[prost(string, tag = "1")]
     pub port_id: ::prost::alloc::string::String,
+    /// channel unique identifier
     #[prost(string, tag = "2")]
     pub channel_id: ::prost::alloc::string::String,
+    /// revision number of the consensus state
+    #[prost(uint64, tag = "3")]
+    pub revision_number: u64,
+    /// revision height of the consensus state
+    #[prost(uint64, tag = "4")]
+    pub revision_height: u64,
+}
+/// QueryChannelClientStateResponse is the Response type for the
+/// Query/QueryChannelClientState RPC method
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryChannelConsensusStateResponse {
+    /// consensus state associated with the channel
+    #[prost(message, optional, tag = "1")]
+    pub consensus_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
+    /// client ID associated with the consensus state
+    #[prost(string, tag = "2")]
+    pub client_id: ::prost::alloc::string::String,
+    /// merkle proof of existence
     #[prost(bytes = "vec", tag = "3")]
-    pub proof_ack: ::prost::alloc::vec::Vec<u8>,
+    pub proof: ::prost::alloc::vec::Vec<u8>,
+    /// height at which the proof was retrieved
     #[prost(message, optional, tag = "4")]
     pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
-    #[prost(string, tag = "5")]
-    pub signer: ::prost::alloc::string::String,
-}
-impl ::prost::Name for MsgChannelOpenConfirm {
-    const NAME: &'static str = "MsgChannelOpenConfirm";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.MsgChannelOpenConfirm".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.MsgChannelOpenConfirm".into()
-    }
-}
-/// MsgChannelOpenConfirmResponse defines the Msg/ChannelOpenConfirm response
-/// type.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct MsgChannelOpenConfirmResponse {}
-impl ::prost::Name for MsgChannelOpenConfirmResponse {
-    const NAME: &'static str = "MsgChannelOpenConfirmResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.MsgChannelOpenConfirmResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.MsgChannelOpenConfirmResponse".into()
-    }
 }
-/// MsgChannelCloseInit defines a msg sent by a Relayer to Chain A
-/// to close a channel with Chain B.
+/// QueryPacketCommitmentRequest is the request type for the
+/// Query/PacketCommitment RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MsgChannelCloseInit {
+pub struct QueryPacketCommitmentRequest {
+    /// port unique identifier
     #[prost(string, tag = "1")]
     pub port_id: ::prost::alloc::string::String,
+    /// channel unique identifier
     #[prost(string, tag = "2")]
     pub channel_id: ::prost::alloc::string::String,
-    #[prost(string, tag = "3")]
-    pub signer: ::prost::alloc::string::String,
-}
-impl ::prost::Name for MsgChannelCloseInit {
-    const NAME: &'static str = "MsgChannelCloseInit";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.MsgChannelCloseInit".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.MsgChannelCloseInit".into()
-    }
-}
-/// MsgChannelCloseInitResponse defines the Msg/ChannelCloseInit response type.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct MsgChannelCloseInitResponse {}
-impl ::prost::Name for MsgChannelCloseInitResponse {
-    const NAME: &'static str = "MsgChannelCloseInitResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.MsgChannelCloseInitResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.MsgChannelCloseInitResponse".into()
-    }
-}
-/// MsgChannelCloseConfirm defines a msg sent by a Relayer to Chain B
-/// to acknowledge the change of channel state to CLOSED on Chain A.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MsgChannelCloseConfirm {
-    #[prost(string, tag = "1")]
-    pub port_id: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub channel_id: ::prost::alloc::string::String,
-    #[prost(bytes = "vec", tag = "3")]
-    pub proof_init: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, optional, tag = "4")]
-    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
-    #[prost(string, tag = "5")]
-    pub signer: ::prost::alloc::string::String,
-}
-impl ::prost::Name for MsgChannelCloseConfirm {
-    const NAME: &'static str = "MsgChannelCloseConfirm";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.MsgChannelCloseConfirm".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.MsgChannelCloseConfirm".into()
-    }
-}
-/// MsgChannelCloseConfirmResponse defines the Msg/ChannelCloseConfirm response
-/// type.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct MsgChannelCloseConfirmResponse {}
-impl ::prost::Name for MsgChannelCloseConfirmResponse {
-    const NAME: &'static str = "MsgChannelCloseConfirmResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.MsgChannelCloseConfirmResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.MsgChannelCloseConfirmResponse".into()
-    }
-}
-/// MsgRecvPacket receives incoming IBC packet
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MsgRecvPacket {
-    #[prost(message, optional, tag = "1")]
-    pub packet: ::core::option::Option<Packet>,
-    #[prost(bytes = "vec", tag = "2")]
-    pub proof_commitment: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, optional, tag = "3")]
-    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
-    #[prost(string, tag = "4")]
-    pub signer: ::prost::alloc::string::String,
-}
-impl ::prost::Name for MsgRecvPacket {
-    const NAME: &'static str = "MsgRecvPacket";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.MsgRecvPacket".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.MsgRecvPacket".into()
-    }
-}
-/// MsgRecvPacketResponse defines the Msg/RecvPacket response type.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct MsgRecvPacketResponse {
-    #[prost(enumeration = "ResponseResultType", tag = "1")]
-    pub result: i32,
-}
-impl ::prost::Name for MsgRecvPacketResponse {
-    const NAME: &'static str = "MsgRecvPacketResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.MsgRecvPacketResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.MsgRecvPacketResponse".into()
-    }
-}
-/// MsgTimeout receives timed-out packet
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MsgTimeout {
-    #[prost(message, optional, tag = "1")]
-    pub packet: ::core::option::Option<Packet>,
-    #[prost(bytes = "vec", tag = "2")]
-    pub proof_unreceived: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, optional, tag = "3")]
-    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
-    #[prost(uint64, tag = "4")]
-    pub next_sequence_recv: u64,
-    #[prost(string, tag = "5")]
-    pub signer: ::prost::alloc::string::String,
-}
-impl ::prost::Name for MsgTimeout {
-    const NAME: &'static str = "MsgTimeout";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.MsgTimeout".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.MsgTimeout".into()
-    }
-}
-/// MsgTimeoutResponse defines the Msg/Timeout response type.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct MsgTimeoutResponse {
-    #[prost(enumeration = "ResponseResultType", tag = "1")]
-    pub result: i32,
-}
-impl ::prost::Name for MsgTimeoutResponse {
-    const NAME: &'static str = "MsgTimeoutResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.MsgTimeoutResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.MsgTimeoutResponse".into()
-    }
-}
-/// MsgTimeoutOnClose timed-out packet upon counterparty channel closure.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MsgTimeoutOnClose {
-    #[prost(message, optional, tag = "1")]
-    pub packet: ::core::option::Option<Packet>,
-    #[prost(bytes = "vec", tag = "2")]
-    pub proof_unreceived: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes = "vec", tag = "3")]
-    pub proof_close: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, optional, tag = "4")]
-    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
-    #[prost(uint64, tag = "5")]
-    pub next_sequence_recv: u64,
-    #[prost(string, tag = "6")]
-    pub signer: ::prost::alloc::string::String,
-}
-impl ::prost::Name for MsgTimeoutOnClose {
-    const NAME: &'static str = "MsgTimeoutOnClose";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.MsgTimeoutOnClose".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.MsgTimeoutOnClose".into()
-    }
-}
-/// MsgTimeoutOnCloseResponse defines the Msg/TimeoutOnClose response type.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct MsgTimeoutOnCloseResponse {
-    #[prost(enumeration = "ResponseResultType", tag = "1")]
-    pub result: i32,
-}
-impl ::prost::Name for MsgTimeoutOnCloseResponse {
-    const NAME: &'static str = "MsgTimeoutOnCloseResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.MsgTimeoutOnCloseResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.MsgTimeoutOnCloseResponse".into()
-    }
-}
-/// MsgAcknowledgement receives incoming IBC acknowledgement
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MsgAcknowledgement {
-    #[prost(message, optional, tag = "1")]
-    pub packet: ::core::option::Option<Packet>,
-    #[prost(bytes = "vec", tag = "2")]
-    pub acknowledgement: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes = "vec", tag = "3")]
-    pub proof_acked: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, optional, tag = "4")]
-    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
-    #[prost(string, tag = "5")]
-    pub signer: ::prost::alloc::string::String,
-}
-impl ::prost::Name for MsgAcknowledgement {
-    const NAME: &'static str = "MsgAcknowledgement";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.MsgAcknowledgement".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.MsgAcknowledgement".into()
-    }
-}
-/// MsgAcknowledgementResponse defines the Msg/Acknowledgement response type.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct MsgAcknowledgementResponse {
-    #[prost(enumeration = "ResponseResultType", tag = "1")]
-    pub result: i32,
-}
-impl ::prost::Name for MsgAcknowledgementResponse {
-    const NAME: &'static str = "MsgAcknowledgementResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.MsgAcknowledgementResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.MsgAcknowledgementResponse".into()
-    }
-}
-/// ResponseResultType defines the possible outcomes of the execution of a message
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum ResponseResultType {
-    /// Default zero value enumeration
-    Unspecified = 0,
-    /// The message did not call the IBC application callbacks (because, for example, the packet had already been relayed)
-    Noop = 1,
-    /// The message was executed successfully
-    Success = 2,
-}
-impl ResponseResultType {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            ResponseResultType::Unspecified => "RESPONSE_RESULT_TYPE_UNSPECIFIED",
-            ResponseResultType::Noop => "RESPONSE_RESULT_TYPE_NOOP",
-            ResponseResultType::Success => "RESPONSE_RESULT_TYPE_SUCCESS",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "RESPONSE_RESULT_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
-            "RESPONSE_RESULT_TYPE_NOOP" => Some(Self::Noop),
-            "RESPONSE_RESULT_TYPE_SUCCESS" => Some(Self::Success),
-            _ => None,
-        }
-    }
-}
-/// Generated client implementations.
-#[cfg(feature = "grpc")]
-pub mod msg_client {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
-    use tonic::codegen::http::Uri;
-    use tonic::codegen::*;
-    /// Msg defines the ibc/channel Msg service.
-    #[derive(Debug, Clone)]
-    pub struct MsgClient<T> {
-        inner: tonic::client::Grpc<T>,
-    }
-    #[cfg(feature = "grpc-transport")]
-    impl MsgClient<tonic::transport::Channel> {
-        /// Attempt to create a new client by connecting to a given endpoint.
-        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
-        where
-            D: TryInto<tonic::transport::Endpoint>,
-            D::Error: Into<StdError>,
-        {
-            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
-            Ok(Self::new(conn))
-        }
-    }
-    impl<T> MsgClient<T>
-    where
-        T: tonic::client::GrpcService<tonic::body::BoxBody>,
-        T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(inner: T, interceptor: F) -> MsgClient<InterceptedService<T, F>>
-        where
-            F: tonic::service::Interceptor,
-            T::ResponseBody: Default,
-            T: tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
-                Response = http::Response<
-                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
-                >,
-            >,
-            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
-                Into<StdError> + Send + Sync,
-        {
-            MsgClient::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
-        }
-        /// ChannelOpenInit defines a rpc handler method for MsgChannelOpenInit.
-        pub async fn channel_open_init(
-            &mut self,
-            request: impl tonic::IntoRequest<super::MsgChannelOpenInit>,
-        ) -> std::result::Result<tonic::Response<super::MsgChannelOpenInitResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path =
-                http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Msg/ChannelOpenInit");
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.channel.v1.Msg",
-                "ChannelOpenInit",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// ChannelOpenTry defines a rpc handler method for MsgChannelOpenTry.
-        pub async fn channel_open_try(
-            &mut self,
-            request: impl tonic::IntoRequest<super::MsgChannelOpenTry>,
-        ) -> std::result::Result<tonic::Response<super::MsgChannelOpenTryResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path =
-                http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Msg/ChannelOpenTry");
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ibc.core.channel.v1.Msg", "ChannelOpenTry"));
-            self.inner.unary(req, path, codec).await
-        }
-        /// ChannelOpenAck defines a rpc handler method for MsgChannelOpenAck.
-        pub async fn channel_open_ack(
-            &mut self,
-            request: impl tonic::IntoRequest<super::MsgChannelOpenAck>,
-        ) -> std::result::Result<tonic::Response<super::MsgChannelOpenAckResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path =
-                http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Msg/ChannelOpenAck");
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ibc.core.channel.v1.Msg", "ChannelOpenAck"));
-            self.inner.unary(req, path, codec).await
-        }
-        /// ChannelOpenConfirm defines a rpc handler method for MsgChannelOpenConfirm.
-        pub async fn channel_open_confirm(
-            &mut self,
-            request: impl tonic::IntoRequest<super::MsgChannelOpenConfirm>,
-        ) -> std::result::Result<tonic::Response<super::MsgChannelOpenConfirmResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path =
-                http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Msg/ChannelOpenConfirm");
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.channel.v1.Msg",
-                "ChannelOpenConfirm",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// ChannelCloseInit defines a rpc handler method for MsgChannelCloseInit.
-        pub async fn channel_close_init(
-            &mut self,
-            request: impl tonic::IntoRequest<super::MsgChannelCloseInit>,
-        ) -> std::result::Result<tonic::Response<super::MsgChannelCloseInitResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path =
-                http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Msg/ChannelCloseInit");
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.channel.v1.Msg",
-                "ChannelCloseInit",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// ChannelCloseConfirm defines a rpc handler method for
-        /// MsgChannelCloseConfirm.
-        pub async fn channel_close_confirm(
-            &mut self,
-            request: impl tonic::IntoRequest<super::MsgChannelCloseConfirm>,
-        ) -> std::result::Result<
-            tonic::Response<super::MsgChannelCloseConfirmResponse>,
-            tonic::Status,
-        > {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/ibc.core.channel.v1.Msg/ChannelCloseConfirm",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.channel.v1.Msg",
-                "ChannelCloseConfirm",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// RecvPacket defines a rpc handler method for MsgRecvPacket.
-        pub async fn recv_packet(
-            &mut self,
-            request: impl tonic::IntoRequest<super::MsgRecvPacket>,
-        ) -> std::result::Result<tonic::Response<super::MsgRecvPacketResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Msg/RecvPacket");
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ibc.core.channel.v1.Msg", "RecvPacket"));
-            self.inner.unary(req, path, codec).await
-        }
-        /// Timeout defines a rpc handler method for MsgTimeout.
-        pub async fn timeout(
-            &mut self,
-            request: impl tonic::IntoRequest<super::MsgTimeout>,
-        ) -> std::result::Result<tonic::Response<super::MsgTimeoutResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Msg/Timeout");
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ibc.core.channel.v1.Msg", "Timeout"));
-            self.inner.unary(req, path, codec).await
-        }
-        /// TimeoutOnClose defines a rpc handler method for MsgTimeoutOnClose.
-        pub async fn timeout_on_close(
-            &mut self,
-            request: impl tonic::IntoRequest<super::MsgTimeoutOnClose>,
-        ) -> std::result::Result<tonic::Response<super::MsgTimeoutOnCloseResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path =
-                http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Msg/TimeoutOnClose");
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ibc.core.channel.v1.Msg", "TimeoutOnClose"));
-            self.inner.unary(req, path, codec).await
-        }
-        /// Acknowledgement defines a rpc handler method for MsgAcknowledgement.
-        pub async fn acknowledgement(
-            &mut self,
-            request: impl tonic::IntoRequest<super::MsgAcknowledgement>,
-        ) -> std::result::Result<tonic::Response<super::MsgAcknowledgementResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path =
-                http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Msg/Acknowledgement");
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.channel.v1.Msg",
-                "Acknowledgement",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-    }
-}
-/// QueryChannelRequest is the request type for the Query/Channel RPC method
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct QueryChannelRequest {
-    /// port unique identifier
-    #[prost(string, tag = "1")]
-    pub port_id: ::prost::alloc::string::String,
-    /// channel unique identifier
-    #[prost(string, tag = "2")]
-    pub channel_id: ::prost::alloc::string::String,
-}
-impl ::prost::Name for QueryChannelRequest {
-    const NAME: &'static str = "QueryChannelRequest";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryChannelRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryChannelRequest".into()
-    }
-}
-/// QueryChannelResponse is the response type for the Query/Channel RPC method.
-/// Besides the Channel end, it includes a proof and the height from which the
-/// proof was retrieved.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct QueryChannelResponse {
-    /// channel associated with the request identifiers
-    #[prost(message, optional, tag = "1")]
-    pub channel: ::core::option::Option<Channel>,
-    /// merkle proof of existence
-    #[prost(bytes = "vec", tag = "2")]
-    pub proof: ::prost::alloc::vec::Vec<u8>,
-    /// height at which the proof was retrieved
-    #[prost(message, optional, tag = "3")]
-    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
-}
-impl ::prost::Name for QueryChannelResponse {
-    const NAME: &'static str = "QueryChannelResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryChannelResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryChannelResponse".into()
-    }
-}
-/// QueryChannelsRequest is the request type for the Query/Channels RPC method
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct QueryChannelsRequest {
-    /// pagination request
-    #[prost(message, optional, tag = "1")]
-    pub pagination: ::core::option::Option<
-        super::super::super::super::cosmos::base::query::v1beta1::PageRequest,
-    >,
-}
-impl ::prost::Name for QueryChannelsRequest {
-    const NAME: &'static str = "QueryChannelsRequest";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryChannelsRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryChannelsRequest".into()
-    }
-}
-/// QueryChannelsResponse is the response type for the Query/Channels RPC method.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct QueryChannelsResponse {
-    /// list of stored channels of the chain.
-    #[prost(message, repeated, tag = "1")]
-    pub channels: ::prost::alloc::vec::Vec<IdentifiedChannel>,
-    /// pagination response
-    #[prost(message, optional, tag = "2")]
-    pub pagination: ::core::option::Option<
-        super::super::super::super::cosmos::base::query::v1beta1::PageResponse,
-    >,
-    /// query block height
-    #[prost(message, optional, tag = "3")]
-    pub height: ::core::option::Option<super::super::client::v1::Height>,
-}
-impl ::prost::Name for QueryChannelsResponse {
-    const NAME: &'static str = "QueryChannelsResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryChannelsResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryChannelsResponse".into()
-    }
-}
-/// QueryConnectionChannelsRequest is the request type for the
-/// Query/QueryConnectionChannels RPC method
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct QueryConnectionChannelsRequest {
-    /// connection unique identifier
-    #[prost(string, tag = "1")]
-    pub connection: ::prost::alloc::string::String,
-    /// pagination request
-    #[prost(message, optional, tag = "2")]
-    pub pagination: ::core::option::Option<
-        super::super::super::super::cosmos::base::query::v1beta1::PageRequest,
-    >,
-}
-impl ::prost::Name for QueryConnectionChannelsRequest {
-    const NAME: &'static str = "QueryConnectionChannelsRequest";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryConnectionChannelsRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryConnectionChannelsRequest".into()
-    }
-}
-/// QueryConnectionChannelsResponse is the Response type for the
-/// Query/QueryConnectionChannels RPC method
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct QueryConnectionChannelsResponse {
-    /// list of channels associated with a connection.
-    #[prost(message, repeated, tag = "1")]
-    pub channels: ::prost::alloc::vec::Vec<IdentifiedChannel>,
-    /// pagination response
-    #[prost(message, optional, tag = "2")]
-    pub pagination: ::core::option::Option<
-        super::super::super::super::cosmos::base::query::v1beta1::PageResponse,
-    >,
-    /// query block height
-    #[prost(message, optional, tag = "3")]
-    pub height: ::core::option::Option<super::super::client::v1::Height>,
-}
-impl ::prost::Name for QueryConnectionChannelsResponse {
-    const NAME: &'static str = "QueryConnectionChannelsResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryConnectionChannelsResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryConnectionChannelsResponse".into()
-    }
-}
-/// QueryChannelClientStateRequest is the request type for the Query/ClientState
-/// RPC method
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct QueryChannelClientStateRequest {
-    /// port unique identifier
-    #[prost(string, tag = "1")]
-    pub port_id: ::prost::alloc::string::String,
-    /// channel unique identifier
-    #[prost(string, tag = "2")]
-    pub channel_id: ::prost::alloc::string::String,
-}
-impl ::prost::Name for QueryChannelClientStateRequest {
-    const NAME: &'static str = "QueryChannelClientStateRequest";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryChannelClientStateRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryChannelClientStateRequest".into()
-    }
-}
-/// QueryChannelClientStateResponse is the Response type for the
-/// Query/QueryChannelClientState RPC method
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct QueryChannelClientStateResponse {
-    /// client state associated with the channel
-    #[prost(message, optional, tag = "1")]
-    pub identified_client_state:
-        ::core::option::Option<super::super::client::v1::IdentifiedClientState>,
-    /// merkle proof of existence
-    #[prost(bytes = "vec", tag = "2")]
-    pub proof: ::prost::alloc::vec::Vec<u8>,
-    /// height at which the proof was retrieved
-    #[prost(message, optional, tag = "3")]
-    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
-}
-impl ::prost::Name for QueryChannelClientStateResponse {
-    const NAME: &'static str = "QueryChannelClientStateResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryChannelClientStateResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryChannelClientStateResponse".into()
-    }
-}
-/// QueryChannelConsensusStateRequest is the request type for the
-/// Query/ConsensusState RPC method
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct QueryChannelConsensusStateRequest {
-    /// port unique identifier
-    #[prost(string, tag = "1")]
-    pub port_id: ::prost::alloc::string::String,
-    /// channel unique identifier
-    #[prost(string, tag = "2")]
-    pub channel_id: ::prost::alloc::string::String,
-    /// revision number of the consensus state
-    #[prost(uint64, tag = "3")]
-    pub revision_number: u64,
-    /// revision height of the consensus state
-    #[prost(uint64, tag = "4")]
-    pub revision_height: u64,
-}
-impl ::prost::Name for QueryChannelConsensusStateRequest {
-    const NAME: &'static str = "QueryChannelConsensusStateRequest";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryChannelConsensusStateRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryChannelConsensusStateRequest".into()
-    }
-}
-/// QueryChannelClientStateResponse is the Response type for the
-/// Query/QueryChannelClientState RPC method
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct QueryChannelConsensusStateResponse {
-    /// consensus state associated with the channel
-    #[prost(message, optional, tag = "1")]
-    pub consensus_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
-    /// client ID associated with the consensus state
-    #[prost(string, tag = "2")]
-    pub client_id: ::prost::alloc::string::String,
-    /// merkle proof of existence
-    #[prost(bytes = "vec", tag = "3")]
-    pub proof: ::prost::alloc::vec::Vec<u8>,
-    /// height at which the proof was retrieved
-    #[prost(message, optional, tag = "4")]
-    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
-}
-impl ::prost::Name for QueryChannelConsensusStateResponse {
-    const NAME: &'static str = "QueryChannelConsensusStateResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryChannelConsensusStateResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryChannelConsensusStateResponse".into()
-    }
-}
-/// QueryPacketCommitmentRequest is the request type for the
-/// Query/PacketCommitment RPC method
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct QueryPacketCommitmentRequest {
-    /// port unique identifier
-    #[prost(string, tag = "1")]
-    pub port_id: ::prost::alloc::string::String,
-    /// channel unique identifier
-    #[prost(string, tag = "2")]
-    pub channel_id: ::prost::alloc::string::String,
-    /// packet sequence
-    #[prost(uint64, tag = "3")]
-    pub sequence: u64,
-}
-impl ::prost::Name for QueryPacketCommitmentRequest {
-    const NAME: &'static str = "QueryPacketCommitmentRequest";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryPacketCommitmentRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryPacketCommitmentRequest".into()
-    }
+    /// packet sequence
+    #[prost(uint64, tag = "3")]
+    pub sequence: u64,
 }
 /// QueryPacketCommitmentResponse defines the client query response for a packet
 /// which also includes a proof and the height from which the proof was
@@ -1344,16 +445,6 @@ pub struct QueryPacketCommitmentResponse {
     #[prost(message, optional, tag = "3")]
     pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
 }
-impl ::prost::Name for QueryPacketCommitmentResponse {
-    const NAME: &'static str = "QueryPacketCommitmentResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryPacketCommitmentResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryPacketCommitmentResponse".into()
-    }
-}
 /// QueryPacketCommitmentsRequest is the request type for the
 /// Query/QueryPacketCommitments RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -1371,16 +462,6 @@ pub struct QueryPacketCommitmentsRequest {
         super::super::super::super::cosmos::base::query::v1beta1::PageRequest,
     >,
 }
-impl ::prost::Name for QueryPacketCommitmentsRequest {
-    const NAME: &'static str = "QueryPacketCommitmentsRequest";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryPacketCommitmentsRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryPacketCommitmentsRequest".into()
-    }
-}
 /// QueryPacketCommitmentsResponse is the request type for the
 /// Query/QueryPacketCommitments RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -1397,16 +478,6 @@ pub struct QueryPacketCommitmentsResponse {
     #[prost(message, optional, tag = "3")]
     pub height: ::core::option::Option<super::super::client::v1::Height>,
 }
-impl ::prost::Name for QueryPacketCommitmentsResponse {
-    const NAME: &'static str = "QueryPacketCommitmentsResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryPacketCommitmentsResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryPacketCommitmentsResponse".into()
-    }
-}
 /// QueryPacketReceiptRequest is the request type for the
 /// Query/PacketReceipt RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -1422,16 +493,6 @@ pub struct QueryPacketReceiptRequest {
     #[prost(uint64, tag = "3")]
     pub sequence: u64,
 }
-impl ::prost::Name for QueryPacketReceiptRequest {
-    const NAME: &'static str = "QueryPacketReceiptRequest";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryPacketReceiptRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryPacketReceiptRequest".into()
-    }
-}
 /// QueryPacketReceiptResponse defines the client query response for a packet
 /// receipt which also includes a proof, and the height from which the proof was
 /// retrieved
@@ -1448,16 +509,6 @@ pub struct QueryPacketReceiptResponse {
     #[prost(message, optional, tag = "4")]
     pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
 }
-impl ::prost::Name for QueryPacketReceiptResponse {
-    const NAME: &'static str = "QueryPacketReceiptResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryPacketReceiptResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryPacketReceiptResponse".into()
-    }
-}
 /// QueryPacketAcknowledgementRequest is the request type for the
 /// Query/PacketAcknowledgement RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -1473,16 +524,6 @@ pub struct QueryPacketAcknowledgementRequest {
     #[prost(uint64, tag = "3")]
     pub sequence: u64,
 }
-impl ::prost::Name for QueryPacketAcknowledgementRequest {
-    const NAME: &'static str = "QueryPacketAcknowledgementRequest";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryPacketAcknowledgementRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryPacketAcknowledgementRequest".into()
-    }
-}
 /// QueryPacketAcknowledgementResponse defines the client query response for a
 /// packet which also includes a proof and the height from which the
 /// proof was retrieved
@@ -1499,16 +540,6 @@ pub struct QueryPacketAcknowledgementResponse {
     #[prost(message, optional, tag = "3")]
     pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
 }
-impl ::prost::Name for QueryPacketAcknowledgementResponse {
-    const NAME: &'static str = "QueryPacketAcknowledgementResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryPacketAcknowledgementResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryPacketAcknowledgementResponse".into()
-    }
-}
 /// QueryPacketAcknowledgementsRequest is the request type for the
 /// Query/QueryPacketCommitments RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -1529,16 +560,6 @@ pub struct QueryPacketAcknowledgementsRequest {
     #[prost(uint64, repeated, tag = "4")]
     pub packet_commitment_sequences: ::prost::alloc::vec::Vec<u64>,
 }
-impl ::prost::Name for QueryPacketAcknowledgementsRequest {
-    const NAME: &'static str = "QueryPacketAcknowledgementsRequest";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryPacketAcknowledgementsRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryPacketAcknowledgementsRequest".into()
-    }
-}
 /// QueryPacketAcknowledgemetsResponse is the request type for the
 /// Query/QueryPacketAcknowledgements RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -1555,609 +576,342 @@ pub struct QueryPacketAcknowledgementsResponse {
     #[prost(message, optional, tag = "3")]
     pub height: ::core::option::Option<super::super::client::v1::Height>,
 }
-impl ::prost::Name for QueryPacketAcknowledgementsResponse {
-    const NAME: &'static str = "QueryPacketAcknowledgementsResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryPacketAcknowledgementsResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryPacketAcknowledgementsResponse".into()
-    }
-}
 /// QueryUnreceivedPacketsRequest is the request type for the
 /// Query/UnreceivedPackets RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct QueryUnreceivedPacketsRequest {
-    /// port unique identifier
+pub struct QueryUnreceivedPacketsRequest {
+    /// port unique identifier
+    #[prost(string, tag = "1")]
+    pub port_id: ::prost::alloc::string::String,
+    /// channel unique identifier
+    #[prost(string, tag = "2")]
+    pub channel_id: ::prost::alloc::string::String,
+    /// list of packet sequences
+    #[prost(uint64, repeated, tag = "3")]
+    pub packet_commitment_sequences: ::prost::alloc::vec::Vec<u64>,
+}
+/// QueryUnreceivedPacketsResponse is the response type for the
+/// Query/UnreceivedPacketCommitments RPC method
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryUnreceivedPacketsResponse {
+    /// list of unreceived packet sequences
+    #[prost(uint64, repeated, tag = "1")]
+    pub sequences: ::prost::alloc::vec::Vec<u64>,
+    /// query block height
+    #[prost(message, optional, tag = "2")]
+    pub height: ::core::option::Option<super::super::client::v1::Height>,
+}
+/// QueryUnreceivedAcks is the request type for the
+/// Query/UnreceivedAcks RPC method
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryUnreceivedAcksRequest {
+    /// port unique identifier
+    #[prost(string, tag = "1")]
+    pub port_id: ::prost::alloc::string::String,
+    /// channel unique identifier
+    #[prost(string, tag = "2")]
+    pub channel_id: ::prost::alloc::string::String,
+    /// list of acknowledgement sequences
+    #[prost(uint64, repeated, tag = "3")]
+    pub packet_ack_sequences: ::prost::alloc::vec::Vec<u64>,
+}
+/// QueryUnreceivedAcksResponse is the response type for the
+/// Query/UnreceivedAcks RPC method
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryUnreceivedAcksResponse {
+    /// list of unreceived acknowledgement sequences
+    #[prost(uint64, repeated, tag = "1")]
+    pub sequences: ::prost::alloc::vec::Vec<u64>,
+    /// query block height
+    #[prost(message, optional, tag = "2")]
+    pub height: ::core::option::Option<super::super::client::v1::Height>,
+}
+/// QueryNextSequenceReceiveRequest is the request type for the
+/// Query/QueryNextSequenceReceiveRequest RPC method
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryNextSequenceReceiveRequest {
+    /// port unique identifier
+    #[prost(string, tag = "1")]
+    pub port_id: ::prost::alloc::string::String,
+    /// channel unique identifier
+    #[prost(string, tag = "2")]
+    pub channel_id: ::prost::alloc::string::String,
+}
+/// QuerySequenceResponse is the request type for the
+/// Query/QueryNextSequenceReceiveResponse RPC method
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct QueryNextSequenceReceiveResponse {
+    /// next sequence receive number
+    #[prost(uint64, tag = "1")]
+    pub next_sequence_receive: u64,
+    /// merkle proof of existence
+    #[prost(bytes = "vec", tag = "2")]
+    pub proof: ::prost::alloc::vec::Vec<u8>,
+    /// height at which the proof was retrieved
+    #[prost(message, optional, tag = "3")]
+    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
+}
+/// MsgChannelOpenInit defines an sdk.Msg to initialize a channel handshake. It
+/// is called by a relayer on Chain A.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgChannelOpenInit {
+    #[prost(string, tag = "1")]
+    pub port_id: ::prost::alloc::string::String,
+    #[prost(message, optional, tag = "2")]
+    pub channel: ::core::option::Option<Channel>,
+    #[prost(string, tag = "3")]
+    pub signer: ::prost::alloc::string::String,
+}
+/// MsgChannelOpenInitResponse defines the Msg/ChannelOpenInit response type.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgChannelOpenInitResponse {
+    #[prost(string, tag = "1")]
+    pub channel_id: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub version: ::prost::alloc::string::String,
+}
+/// MsgChannelOpenInit defines a msg sent by a Relayer to try to open a channel
+/// on Chain B. The version field within the Channel field has been deprecated. Its
+/// value will be ignored by core IBC.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgChannelOpenTry {
+    #[prost(string, tag = "1")]
+    pub port_id: ::prost::alloc::string::String,
+    /// Deprecated: this field is unused. Crossing hello's are no longer supported in core IBC.
+    #[deprecated]
+    #[prost(string, tag = "2")]
+    pub previous_channel_id: ::prost::alloc::string::String,
+    /// NOTE: the version field within the channel has been deprecated. Its value will be ignored by core IBC.
+    #[prost(message, optional, tag = "3")]
+    pub channel: ::core::option::Option<Channel>,
+    #[prost(string, tag = "4")]
+    pub counterparty_version: ::prost::alloc::string::String,
+    #[prost(bytes = "vec", tag = "5")]
+    pub proof_init: ::prost::alloc::vec::Vec<u8>,
+    #[prost(message, optional, tag = "6")]
+    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
+    #[prost(string, tag = "7")]
+    pub signer: ::prost::alloc::string::String,
+}
+/// MsgChannelOpenTryResponse defines the Msg/ChannelOpenTry response type.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgChannelOpenTryResponse {
+    #[prost(string, tag = "1")]
+    pub version: ::prost::alloc::string::String,
+}
+/// MsgChannelOpenAck defines a msg sent by a Relayer to Chain A to acknowledge
+/// the change of channel state to TRYOPEN on Chain B.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgChannelOpenAck {
+    #[prost(string, tag = "1")]
+    pub port_id: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub channel_id: ::prost::alloc::string::String,
+    #[prost(string, tag = "3")]
+    pub counterparty_channel_id: ::prost::alloc::string::String,
+    #[prost(string, tag = "4")]
+    pub counterparty_version: ::prost::alloc::string::String,
+    #[prost(bytes = "vec", tag = "5")]
+    pub proof_try: ::prost::alloc::vec::Vec<u8>,
+    #[prost(message, optional, tag = "6")]
+    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
+    #[prost(string, tag = "7")]
+    pub signer: ::prost::alloc::string::String,
+}
+/// MsgChannelOpenAckResponse defines the Msg/ChannelOpenAck response type.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgChannelOpenAckResponse {}
+/// MsgChannelOpenConfirm defines a msg sent by a Relayer to Chain B to
+/// acknowledge the change of channel state to OPEN on Chain A.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgChannelOpenConfirm {
     #[prost(string, tag = "1")]
     pub port_id: ::prost::alloc::string::String,
-    /// channel unique identifier
     #[prost(string, tag = "2")]
     pub channel_id: ::prost::alloc::string::String,
-    /// list of packet sequences
-    #[prost(uint64, repeated, tag = "3")]
-    pub packet_commitment_sequences: ::prost::alloc::vec::Vec<u64>,
-}
-impl ::prost::Name for QueryUnreceivedPacketsRequest {
-    const NAME: &'static str = "QueryUnreceivedPacketsRequest";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryUnreceivedPacketsRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryUnreceivedPacketsRequest".into()
-    }
+    #[prost(bytes = "vec", tag = "3")]
+    pub proof_ack: ::prost::alloc::vec::Vec<u8>,
+    #[prost(message, optional, tag = "4")]
+    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
+    #[prost(string, tag = "5")]
+    pub signer: ::prost::alloc::string::String,
 }
-/// QueryUnreceivedPacketsResponse is the response type for the
-/// Query/UnreceivedPacketCommitments RPC method
+/// MsgChannelOpenConfirmResponse defines the Msg/ChannelOpenConfirm response
+/// type.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct QueryUnreceivedPacketsResponse {
-    /// list of unreceived packet sequences
-    #[prost(uint64, repeated, tag = "1")]
-    pub sequences: ::prost::alloc::vec::Vec<u64>,
-    /// query block height
-    #[prost(message, optional, tag = "2")]
-    pub height: ::core::option::Option<super::super::client::v1::Height>,
-}
-impl ::prost::Name for QueryUnreceivedPacketsResponse {
-    const NAME: &'static str = "QueryUnreceivedPacketsResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryUnreceivedPacketsResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryUnreceivedPacketsResponse".into()
-    }
-}
-/// QueryUnreceivedAcks is the request type for the
-/// Query/UnreceivedAcks RPC method
+pub struct MsgChannelOpenConfirmResponse {}
+/// MsgChannelCloseInit defines a msg sent by a Relayer to Chain A
+/// to close a channel with Chain B.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct QueryUnreceivedAcksRequest {
-    /// port unique identifier
+pub struct MsgChannelCloseInit {
     #[prost(string, tag = "1")]
     pub port_id: ::prost::alloc::string::String,
-    /// channel unique identifier
     #[prost(string, tag = "2")]
     pub channel_id: ::prost::alloc::string::String,
-    /// list of acknowledgement sequences
-    #[prost(uint64, repeated, tag = "3")]
-    pub packet_ack_sequences: ::prost::alloc::vec::Vec<u64>,
-}
-impl ::prost::Name for QueryUnreceivedAcksRequest {
-    const NAME: &'static str = "QueryUnreceivedAcksRequest";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryUnreceivedAcksRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryUnreceivedAcksRequest".into()
-    }
+    #[prost(string, tag = "3")]
+    pub signer: ::prost::alloc::string::String,
 }
-/// QueryUnreceivedAcksResponse is the response type for the
-/// Query/UnreceivedAcks RPC method
+/// MsgChannelCloseInitResponse defines the Msg/ChannelCloseInit response type.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct QueryUnreceivedAcksResponse {
-    /// list of unreceived acknowledgement sequences
-    #[prost(uint64, repeated, tag = "1")]
-    pub sequences: ::prost::alloc::vec::Vec<u64>,
-    /// query block height
-    #[prost(message, optional, tag = "2")]
-    pub height: ::core::option::Option<super::super::client::v1::Height>,
-}
-impl ::prost::Name for QueryUnreceivedAcksResponse {
-    const NAME: &'static str = "QueryUnreceivedAcksResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryUnreceivedAcksResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryUnreceivedAcksResponse".into()
-    }
-}
-/// QueryNextSequenceReceiveRequest is the request type for the
-/// Query/QueryNextSequenceReceiveRequest RPC method
+pub struct MsgChannelCloseInitResponse {}
+/// MsgChannelCloseConfirm defines a msg sent by a Relayer to Chain B
+/// to acknowledge the change of channel state to CLOSED on Chain A.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct QueryNextSequenceReceiveRequest {
-    /// port unique identifier
+pub struct MsgChannelCloseConfirm {
     #[prost(string, tag = "1")]
     pub port_id: ::prost::alloc::string::String,
-    /// channel unique identifier
     #[prost(string, tag = "2")]
     pub channel_id: ::prost::alloc::string::String,
+    #[prost(bytes = "vec", tag = "3")]
+    pub proof_init: ::prost::alloc::vec::Vec<u8>,
+    #[prost(message, optional, tag = "4")]
+    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
+    #[prost(string, tag = "5")]
+    pub signer: ::prost::alloc::string::String,
 }
-impl ::prost::Name for QueryNextSequenceReceiveRequest {
-    const NAME: &'static str = "QueryNextSequenceReceiveRequest";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryNextSequenceReceiveRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryNextSequenceReceiveRequest".into()
-    }
+/// MsgChannelCloseConfirmResponse defines the Msg/ChannelCloseConfirm response
+/// type.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgChannelCloseConfirmResponse {}
+/// MsgRecvPacket receives incoming IBC packet
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgRecvPacket {
+    #[prost(message, optional, tag = "1")]
+    pub packet: ::core::option::Option<Packet>,
+    #[prost(bytes = "vec", tag = "2")]
+    pub proof_commitment: ::prost::alloc::vec::Vec<u8>,
+    #[prost(message, optional, tag = "3")]
+    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
+    #[prost(string, tag = "4")]
+    pub signer: ::prost::alloc::string::String,
 }
-/// QuerySequenceResponse is the request type for the
-/// Query/QueryNextSequenceReceiveResponse RPC method
+/// MsgRecvPacketResponse defines the Msg/RecvPacket response type.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct QueryNextSequenceReceiveResponse {
-    /// next sequence receive number
-    #[prost(uint64, tag = "1")]
-    pub next_sequence_receive: u64,
-    /// merkle proof of existence
+pub struct MsgRecvPacketResponse {
+    #[prost(enumeration = "ResponseResultType", tag = "1")]
+    pub result: i32,
+}
+/// MsgTimeout receives timed-out packet
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgTimeout {
+    #[prost(message, optional, tag = "1")]
+    pub packet: ::core::option::Option<Packet>,
     #[prost(bytes = "vec", tag = "2")]
-    pub proof: ::prost::alloc::vec::Vec<u8>,
-    /// height at which the proof was retrieved
+    pub proof_unreceived: ::prost::alloc::vec::Vec<u8>,
     #[prost(message, optional, tag = "3")]
     pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
+    #[prost(uint64, tag = "4")]
+    pub next_sequence_recv: u64,
+    #[prost(string, tag = "5")]
+    pub signer: ::prost::alloc::string::String,
 }
-impl ::prost::Name for QueryNextSequenceReceiveResponse {
-    const NAME: &'static str = "QueryNextSequenceReceiveResponse";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.QueryNextSequenceReceiveResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.QueryNextSequenceReceiveResponse".into()
-    }
+/// MsgTimeoutResponse defines the Msg/Timeout response type.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgTimeoutResponse {
+    #[prost(enumeration = "ResponseResultType", tag = "1")]
+    pub result: i32,
 }
-/// Generated client implementations.
-#[cfg(feature = "grpc")]
-pub mod query_client {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
-    use tonic::codegen::http::Uri;
-    use tonic::codegen::*;
-    /// Query provides defines the gRPC querier service
-    #[derive(Debug, Clone)]
-    pub struct QueryClient<T> {
-        inner: tonic::client::Grpc<T>,
-    }
-    #[cfg(feature = "grpc-transport")]
-    impl QueryClient<tonic::transport::Channel> {
-        /// Attempt to create a new client by connecting to a given endpoint.
-        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
-        where
-            D: TryInto<tonic::transport::Endpoint>,
-            D::Error: Into<StdError>,
-        {
-            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
-            Ok(Self::new(conn))
-        }
-    }
-    impl<T> QueryClient<T>
-    where
-        T: tonic::client::GrpcService<tonic::body::BoxBody>,
-        T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(
-            inner: T,
-            interceptor: F,
-        ) -> QueryClient<InterceptedService<T, F>>
-        where
-            F: tonic::service::Interceptor,
-            T::ResponseBody: Default,
-            T: tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
-                Response = http::Response<
-                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
-                >,
-            >,
-            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
-                Into<StdError> + Send + Sync,
-        {
-            QueryClient::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
-        }
-        /// Channel queries an IBC Channel.
-        pub async fn channel(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryChannelRequest>,
-        ) -> std::result::Result<tonic::Response<super::QueryChannelResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Query/Channel");
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ibc.core.channel.v1.Query", "Channel"));
-            self.inner.unary(req, path, codec).await
-        }
-        /// Channels queries all the IBC channels of a chain.
-        pub async fn channels(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryChannelsRequest>,
-        ) -> std::result::Result<tonic::Response<super::QueryChannelsResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Query/Channels");
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ibc.core.channel.v1.Query", "Channels"));
-            self.inner.unary(req, path, codec).await
-        }
-        /// ConnectionChannels queries all the channels associated with a connection
-        /// end.
-        pub async fn connection_channels(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryConnectionChannelsRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::QueryConnectionChannelsResponse>,
-            tonic::Status,
-        > {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/ibc.core.channel.v1.Query/ConnectionChannels",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.channel.v1.Query",
-                "ConnectionChannels",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// ChannelClientState queries for the client state for the channel associated
-        /// with the provided channel identifiers.
-        pub async fn channel_client_state(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryChannelClientStateRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::QueryChannelClientStateResponse>,
-            tonic::Status,
-        > {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/ibc.core.channel.v1.Query/ChannelClientState",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.channel.v1.Query",
-                "ChannelClientState",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// ChannelConsensusState queries for the consensus state for the channel
-        /// associated with the provided channel identifiers.
-        pub async fn channel_consensus_state(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryChannelConsensusStateRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::QueryChannelConsensusStateResponse>,
-            tonic::Status,
-        > {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/ibc.core.channel.v1.Query/ChannelConsensusState",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.channel.v1.Query",
-                "ChannelConsensusState",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// PacketCommitment queries a stored packet commitment hash.
-        pub async fn packet_commitment(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryPacketCommitmentRequest>,
-        ) -> std::result::Result<tonic::Response<super::QueryPacketCommitmentResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path =
-                http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Query/PacketCommitment");
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.channel.v1.Query",
-                "PacketCommitment",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// PacketCommitments returns all the packet commitments hashes associated
-        /// with a channel.
-        pub async fn packet_commitments(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryPacketCommitmentsRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::QueryPacketCommitmentsResponse>,
-            tonic::Status,
-        > {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/ibc.core.channel.v1.Query/PacketCommitments",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.channel.v1.Query",
-                "PacketCommitments",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// PacketReceipt queries if a given packet sequence has been received on the
-        /// queried chain
-        pub async fn packet_receipt(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryPacketReceiptRequest>,
-        ) -> std::result::Result<tonic::Response<super::QueryPacketReceiptResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path =
-                http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Query/PacketReceipt");
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.channel.v1.Query",
-                "PacketReceipt",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// PacketAcknowledgement queries a stored packet acknowledgement hash.
-        pub async fn packet_acknowledgement(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryPacketAcknowledgementRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::QueryPacketAcknowledgementResponse>,
-            tonic::Status,
-        > {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/ibc.core.channel.v1.Query/PacketAcknowledgement",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.channel.v1.Query",
-                "PacketAcknowledgement",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// PacketAcknowledgements returns all the packet acknowledgements associated
-        /// with a channel.
-        pub async fn packet_acknowledgements(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryPacketAcknowledgementsRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::QueryPacketAcknowledgementsResponse>,
-            tonic::Status,
-        > {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/ibc.core.channel.v1.Query/PacketAcknowledgements",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.channel.v1.Query",
-                "PacketAcknowledgements",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// UnreceivedPackets returns all the unreceived IBC packets associated with a
-        /// channel and sequences.
-        pub async fn unreceived_packets(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryUnreceivedPacketsRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::QueryUnreceivedPacketsResponse>,
-            tonic::Status,
-        > {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/ibc.core.channel.v1.Query/UnreceivedPackets",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.channel.v1.Query",
-                "UnreceivedPackets",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// UnreceivedAcks returns all the unreceived IBC acknowledgements associated
-        /// with a channel and sequences.
-        pub async fn unreceived_acks(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryUnreceivedAcksRequest>,
-        ) -> std::result::Result<tonic::Response<super::QueryUnreceivedAcksResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path =
-                http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Query/UnreceivedAcks");
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.channel.v1.Query",
-                "UnreceivedAcks",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// NextSequenceReceive returns the next receive sequence for a given channel.
-        pub async fn next_sequence_receive(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryNextSequenceReceiveRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::QueryNextSequenceReceiveResponse>,
-            tonic::Status,
-        > {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/ibc.core.channel.v1.Query/NextSequenceReceive",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.channel.v1.Query",
-                "NextSequenceReceive",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-    }
+/// MsgTimeoutOnClose timed-out packet upon counterparty channel closure.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgTimeoutOnClose {
+    #[prost(message, optional, tag = "1")]
+    pub packet: ::core::option::Option<Packet>,
+    #[prost(bytes = "vec", tag = "2")]
+    pub proof_unreceived: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "vec", tag = "3")]
+    pub proof_close: ::prost::alloc::vec::Vec<u8>,
+    #[prost(message, optional, tag = "4")]
+    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
+    #[prost(uint64, tag = "5")]
+    pub next_sequence_recv: u64,
+    #[prost(string, tag = "6")]
+    pub signer: ::prost::alloc::string::String,
 }
-/// GenesisState defines the ibc channel submodule's genesis state.
+/// MsgTimeoutOnCloseResponse defines the Msg/TimeoutOnClose response type.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GenesisState {
-    #[prost(message, repeated, tag = "1")]
-    pub channels: ::prost::alloc::vec::Vec<IdentifiedChannel>,
-    #[prost(message, repeated, tag = "2")]
-    pub acknowledgements: ::prost::alloc::vec::Vec<PacketState>,
-    #[prost(message, repeated, tag = "3")]
-    pub commitments: ::prost::alloc::vec::Vec<PacketState>,
-    #[prost(message, repeated, tag = "4")]
-    pub receipts: ::prost::alloc::vec::Vec<PacketState>,
-    #[prost(message, repeated, tag = "5")]
-    pub send_sequences: ::prost::alloc::vec::Vec<PacketSequence>,
-    #[prost(message, repeated, tag = "6")]
-    pub recv_sequences: ::prost::alloc::vec::Vec<PacketSequence>,
-    #[prost(message, repeated, tag = "7")]
-    pub ack_sequences: ::prost::alloc::vec::Vec<PacketSequence>,
-    /// the sequence for the next generated channel identifier
-    #[prost(uint64, tag = "8")]
-    pub next_channel_sequence: u64,
+pub struct MsgTimeoutOnCloseResponse {
+    #[prost(enumeration = "ResponseResultType", tag = "1")]
+    pub result: i32,
 }
-impl ::prost::Name for GenesisState {
-    const NAME: &'static str = "GenesisState";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.GenesisState".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.GenesisState".into()
-    }
+/// MsgAcknowledgement receives incoming IBC acknowledgement
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgAcknowledgement {
+    #[prost(message, optional, tag = "1")]
+    pub packet: ::core::option::Option<Packet>,
+    #[prost(bytes = "vec", tag = "2")]
+    pub acknowledgement: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "vec", tag = "3")]
+    pub proof_acked: ::prost::alloc::vec::Vec<u8>,
+    #[prost(message, optional, tag = "4")]
+    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
+    #[prost(string, tag = "5")]
+    pub signer: ::prost::alloc::string::String,
 }
-/// PacketSequence defines the genesis type necessary to retrieve and store
-/// next send and receive sequences.
+/// MsgAcknowledgementResponse defines the Msg/Acknowledgement response type.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PacketSequence {
-    #[prost(string, tag = "1")]
-    pub port_id: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub channel_id: ::prost::alloc::string::String,
-    #[prost(uint64, tag = "3")]
-    pub sequence: u64,
+pub struct MsgAcknowledgementResponse {
+    #[prost(enumeration = "ResponseResultType", tag = "1")]
+    pub result: i32,
+}
+/// ResponseResultType defines the possible outcomes of the execution of a message
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum ResponseResultType {
+    /// Default zero value enumeration
+    Unspecified = 0,
+    /// The message did not call the IBC application callbacks (because, for example, the packet had already been relayed)
+    Noop = 1,
+    /// The message was executed successfully
+    Success = 2,
 }
-impl ::prost::Name for PacketSequence {
-    const NAME: &'static str = "PacketSequence";
-    const PACKAGE: &'static str = "ibc.core.channel.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.channel.v1.PacketSequence".into()
+impl ResponseResultType {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            ResponseResultType::Unspecified => "RESPONSE_RESULT_TYPE_UNSPECIFIED",
+            ResponseResultType::Noop => "RESPONSE_RESULT_TYPE_NOOP",
+            ResponseResultType::Success => "RESPONSE_RESULT_TYPE_SUCCESS",
+        }
     }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.channel.v1.PacketSequence".into()
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "RESPONSE_RESULT_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
+            "RESPONSE_RESULT_TYPE_NOOP" => Some(Self::Noop),
+            "RESPONSE_RESULT_TYPE_SUCCESS" => Some(Self::Success),
+            _ => None,
+        }
     }
 }
+include!("ibc.core.channel.v1.serde.rs");
+include!("ibc.core.channel.v1.tonic.rs");
+// @@protoc_insertion_point(module)
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.channel.v1.serde.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.channel.v1.serde.rs
new file mode 100644
index 00000000..b43bc7e4
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.channel.v1.serde.rs
@@ -0,0 +1,8234 @@
+// @generated
+#[cfg(feature = "serde")]
+impl serde::Serialize for Acknowledgement {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.response.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.Acknowledgement", len)?;
+        if let Some(v) = self.response.as_ref() {
+            match v {
+                acknowledgement::Response::Result(v) => {
+                    #[allow(clippy::needless_borrow)]
+                    struct_ser
+                        .serialize_field("result", pbjson::private::base64::encode(&v).as_str())?;
+                }
+                acknowledgement::Response::Error(v) => {
+                    struct_ser.serialize_field("error", v)?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Acknowledgement {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["result", "error"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Result,
+            Error,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "result" => Ok(GeneratedField::Result),
+                            "error" => Ok(GeneratedField::Error),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Acknowledgement;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.Acknowledgement")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Acknowledgement, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut response__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Result => {
+                            if response__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("result"));
+                            }
+                            response__ = map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| acknowledgement::Response::Result(x.0));
+                        }
+                        GeneratedField::Error => {
+                            if response__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("error"));
+                            }
+                            response__ = map_
+                                .next_value::<::std::option::Option<_>>()?
+                                .map(acknowledgement::Response::Error);
+                        }
+                    }
+                }
+                Ok(Acknowledgement {
+                    response: response__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.Acknowledgement",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Channel {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.state != 0 {
+            len += 1;
+        }
+        if self.ordering != 0 {
+            len += 1;
+        }
+        if self.counterparty.is_some() {
+            len += 1;
+        }
+        if !self.connection_hops.is_empty() {
+            len += 1;
+        }
+        if !self.version.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.Channel", len)?;
+        if self.state != 0 {
+            let v = State::try_from(self.state).map_err(|_| {
+                serde::ser::Error::custom(format!("Invalid variant {}", self.state))
+            })?;
+            struct_ser.serialize_field("state", &v)?;
+        }
+        if self.ordering != 0 {
+            let v = Order::try_from(self.ordering).map_err(|_| {
+                serde::ser::Error::custom(format!("Invalid variant {}", self.ordering))
+            })?;
+            struct_ser.serialize_field("ordering", &v)?;
+        }
+        if let Some(v) = self.counterparty.as_ref() {
+            struct_ser.serialize_field("counterparty", v)?;
+        }
+        if !self.connection_hops.is_empty() {
+            struct_ser.serialize_field("connectionHops", &self.connection_hops)?;
+        }
+        if !self.version.is_empty() {
+            struct_ser.serialize_field("version", &self.version)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Channel {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "state",
+            "ordering",
+            "counterparty",
+            "connection_hops",
+            "connectionHops",
+            "version",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            State,
+            Ordering,
+            Counterparty,
+            ConnectionHops,
+            Version,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "state" => Ok(GeneratedField::State),
+                            "ordering" => Ok(GeneratedField::Ordering),
+                            "counterparty" => Ok(GeneratedField::Counterparty),
+                            "connectionHops" | "connection_hops" => {
+                                Ok(GeneratedField::ConnectionHops)
+                            }
+                            "version" => Ok(GeneratedField::Version),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Channel;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.Channel")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Channel, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut state__ = None;
+                let mut ordering__ = None;
+                let mut counterparty__ = None;
+                let mut connection_hops__ = None;
+                let mut version__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::State => {
+                            if state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("state"));
+                            }
+                            state__ = Some(map_.next_value::<State>()? as i32);
+                        }
+                        GeneratedField::Ordering => {
+                            if ordering__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("ordering"));
+                            }
+                            ordering__ = Some(map_.next_value::<Order>()? as i32);
+                        }
+                        GeneratedField::Counterparty => {
+                            if counterparty__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("counterparty"));
+                            }
+                            counterparty__ = map_.next_value()?;
+                        }
+                        GeneratedField::ConnectionHops => {
+                            if connection_hops__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("connectionHops"));
+                            }
+                            connection_hops__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Version => {
+                            if version__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("version"));
+                            }
+                            version__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(Channel {
+                    state: state__.unwrap_or_default(),
+                    ordering: ordering__.unwrap_or_default(),
+                    counterparty: counterparty__,
+                    connection_hops: connection_hops__.unwrap_or_default(),
+                    version: version__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("ibc.core.channel.v1.Channel", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Counterparty {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.Counterparty", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Counterparty {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["port_id", "portId", "channel_id", "channelId"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Counterparty;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.Counterparty")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Counterparty, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(Counterparty {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.Counterparty",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for GenesisState {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.channels.is_empty() {
+            len += 1;
+        }
+        if !self.acknowledgements.is_empty() {
+            len += 1;
+        }
+        if !self.commitments.is_empty() {
+            len += 1;
+        }
+        if !self.receipts.is_empty() {
+            len += 1;
+        }
+        if !self.send_sequences.is_empty() {
+            len += 1;
+        }
+        if !self.recv_sequences.is_empty() {
+            len += 1;
+        }
+        if !self.ack_sequences.is_empty() {
+            len += 1;
+        }
+        if self.next_channel_sequence != 0 {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.GenesisState", len)?;
+        if !self.channels.is_empty() {
+            struct_ser.serialize_field("channels", &self.channels)?;
+        }
+        if !self.acknowledgements.is_empty() {
+            struct_ser.serialize_field("acknowledgements", &self.acknowledgements)?;
+        }
+        if !self.commitments.is_empty() {
+            struct_ser.serialize_field("commitments", &self.commitments)?;
+        }
+        if !self.receipts.is_empty() {
+            struct_ser.serialize_field("receipts", &self.receipts)?;
+        }
+        if !self.send_sequences.is_empty() {
+            struct_ser.serialize_field("sendSequences", &self.send_sequences)?;
+        }
+        if !self.recv_sequences.is_empty() {
+            struct_ser.serialize_field("recvSequences", &self.recv_sequences)?;
+        }
+        if !self.ack_sequences.is_empty() {
+            struct_ser.serialize_field("ackSequences", &self.ack_sequences)?;
+        }
+        if self.next_channel_sequence != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "nextChannelSequence",
+                ToString::to_string(&self.next_channel_sequence).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for GenesisState {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "channels",
+            "acknowledgements",
+            "commitments",
+            "receipts",
+            "send_sequences",
+            "sendSequences",
+            "recv_sequences",
+            "recvSequences",
+            "ack_sequences",
+            "ackSequences",
+            "next_channel_sequence",
+            "nextChannelSequence",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Channels,
+            Acknowledgements,
+            Commitments,
+            Receipts,
+            SendSequences,
+            RecvSequences,
+            AckSequences,
+            NextChannelSequence,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "channels" => Ok(GeneratedField::Channels),
+                            "acknowledgements" => Ok(GeneratedField::Acknowledgements),
+                            "commitments" => Ok(GeneratedField::Commitments),
+                            "receipts" => Ok(GeneratedField::Receipts),
+                            "sendSequences" | "send_sequences" => Ok(GeneratedField::SendSequences),
+                            "recvSequences" | "recv_sequences" => Ok(GeneratedField::RecvSequences),
+                            "ackSequences" | "ack_sequences" => Ok(GeneratedField::AckSequences),
+                            "nextChannelSequence" | "next_channel_sequence" => {
+                                Ok(GeneratedField::NextChannelSequence)
+                            }
+                            _ => 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 std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.GenesisState")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GenesisState, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut channels__ = None;
+                let mut acknowledgements__ = None;
+                let mut commitments__ = None;
+                let mut receipts__ = None;
+                let mut send_sequences__ = None;
+                let mut recv_sequences__ = None;
+                let mut ack_sequences__ = None;
+                let mut next_channel_sequence__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Channels => {
+                            if channels__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channels"));
+                            }
+                            channels__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Acknowledgements => {
+                            if acknowledgements__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("acknowledgements"));
+                            }
+                            acknowledgements__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Commitments => {
+                            if commitments__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("commitments"));
+                            }
+                            commitments__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Receipts => {
+                            if receipts__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("receipts"));
+                            }
+                            receipts__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::SendSequences => {
+                            if send_sequences__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sendSequences"));
+                            }
+                            send_sequences__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::RecvSequences => {
+                            if recv_sequences__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("recvSequences"));
+                            }
+                            recv_sequences__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::AckSequences => {
+                            if ack_sequences__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("ackSequences"));
+                            }
+                            ack_sequences__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::NextChannelSequence => {
+                            if next_channel_sequence__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "nextChannelSequence",
+                                ));
+                            }
+                            next_channel_sequence__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(GenesisState {
+                    channels: channels__.unwrap_or_default(),
+                    acknowledgements: acknowledgements__.unwrap_or_default(),
+                    commitments: commitments__.unwrap_or_default(),
+                    receipts: receipts__.unwrap_or_default(),
+                    send_sequences: send_sequences__.unwrap_or_default(),
+                    recv_sequences: recv_sequences__.unwrap_or_default(),
+                    ack_sequences: ack_sequences__.unwrap_or_default(),
+                    next_channel_sequence: next_channel_sequence__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.GenesisState",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for IdentifiedChannel {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.state != 0 {
+            len += 1;
+        }
+        if self.ordering != 0 {
+            len += 1;
+        }
+        if self.counterparty.is_some() {
+            len += 1;
+        }
+        if !self.connection_hops.is_empty() {
+            len += 1;
+        }
+        if !self.version.is_empty() {
+            len += 1;
+        }
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.IdentifiedChannel", len)?;
+        if self.state != 0 {
+            let v = State::try_from(self.state).map_err(|_| {
+                serde::ser::Error::custom(format!("Invalid variant {}", self.state))
+            })?;
+            struct_ser.serialize_field("state", &v)?;
+        }
+        if self.ordering != 0 {
+            let v = Order::try_from(self.ordering).map_err(|_| {
+                serde::ser::Error::custom(format!("Invalid variant {}", self.ordering))
+            })?;
+            struct_ser.serialize_field("ordering", &v)?;
+        }
+        if let Some(v) = self.counterparty.as_ref() {
+            struct_ser.serialize_field("counterparty", v)?;
+        }
+        if !self.connection_hops.is_empty() {
+            struct_ser.serialize_field("connectionHops", &self.connection_hops)?;
+        }
+        if !self.version.is_empty() {
+            struct_ser.serialize_field("version", &self.version)?;
+        }
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for IdentifiedChannel {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "state",
+            "ordering",
+            "counterparty",
+            "connection_hops",
+            "connectionHops",
+            "version",
+            "port_id",
+            "portId",
+            "channel_id",
+            "channelId",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            State,
+            Ordering,
+            Counterparty,
+            ConnectionHops,
+            Version,
+            PortId,
+            ChannelId,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "state" => Ok(GeneratedField::State),
+                            "ordering" => Ok(GeneratedField::Ordering),
+                            "counterparty" => Ok(GeneratedField::Counterparty),
+                            "connectionHops" | "connection_hops" => {
+                                Ok(GeneratedField::ConnectionHops)
+                            }
+                            "version" => Ok(GeneratedField::Version),
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = IdentifiedChannel;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.IdentifiedChannel")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<IdentifiedChannel, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut state__ = None;
+                let mut ordering__ = None;
+                let mut counterparty__ = None;
+                let mut connection_hops__ = None;
+                let mut version__ = None;
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::State => {
+                            if state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("state"));
+                            }
+                            state__ = Some(map_.next_value::<State>()? as i32);
+                        }
+                        GeneratedField::Ordering => {
+                            if ordering__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("ordering"));
+                            }
+                            ordering__ = Some(map_.next_value::<Order>()? as i32);
+                        }
+                        GeneratedField::Counterparty => {
+                            if counterparty__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("counterparty"));
+                            }
+                            counterparty__ = map_.next_value()?;
+                        }
+                        GeneratedField::ConnectionHops => {
+                            if connection_hops__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("connectionHops"));
+                            }
+                            connection_hops__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Version => {
+                            if version__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("version"));
+                            }
+                            version__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(IdentifiedChannel {
+                    state: state__.unwrap_or_default(),
+                    ordering: ordering__.unwrap_or_default(),
+                    counterparty: counterparty__,
+                    connection_hops: connection_hops__.unwrap_or_default(),
+                    version: version__.unwrap_or_default(),
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.IdentifiedChannel",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgAcknowledgement {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.packet.is_some() {
+            len += 1;
+        }
+        if !self.acknowledgement.is_empty() {
+            len += 1;
+        }
+        if !self.proof_acked.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        if !self.signer.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.MsgAcknowledgement", len)?;
+        if let Some(v) = self.packet.as_ref() {
+            struct_ser.serialize_field("packet", v)?;
+        }
+        if !self.acknowledgement.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "acknowledgement",
+                pbjson::private::base64::encode(&self.acknowledgement).as_str(),
+            )?;
+        }
+        if !self.proof_acked.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "proofAcked",
+                pbjson::private::base64::encode(&self.proof_acked).as_str(),
+            )?;
+        }
+        if let Some(v) = self.proof_height.as_ref() {
+            struct_ser.serialize_field("proofHeight", v)?;
+        }
+        if !self.signer.is_empty() {
+            struct_ser.serialize_field("signer", &self.signer)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgAcknowledgement {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "packet",
+            "acknowledgement",
+            "proof_acked",
+            "proofAcked",
+            "proof_height",
+            "proofHeight",
+            "signer",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Packet,
+            Acknowledgement,
+            ProofAcked,
+            ProofHeight,
+            Signer,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "packet" => Ok(GeneratedField::Packet),
+                            "acknowledgement" => Ok(GeneratedField::Acknowledgement),
+                            "proofAcked" | "proof_acked" => Ok(GeneratedField::ProofAcked),
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            "signer" => Ok(GeneratedField::Signer),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgAcknowledgement;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.MsgAcknowledgement")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MsgAcknowledgement, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut packet__ = None;
+                let mut acknowledgement__ = None;
+                let mut proof_acked__ = None;
+                let mut proof_height__ = None;
+                let mut signer__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Packet => {
+                            if packet__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("packet"));
+                            }
+                            packet__ = map_.next_value()?;
+                        }
+                        GeneratedField::Acknowledgement => {
+                            if acknowledgement__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("acknowledgement"));
+                            }
+                            acknowledgement__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::ProofAcked => {
+                            if proof_acked__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofAcked"));
+                            }
+                            proof_acked__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::ProofHeight => {
+                            if proof_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofHeight"));
+                            }
+                            proof_height__ = map_.next_value()?;
+                        }
+                        GeneratedField::Signer => {
+                            if signer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signer"));
+                            }
+                            signer__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgAcknowledgement {
+                    packet: packet__,
+                    acknowledgement: acknowledgement__.unwrap_or_default(),
+                    proof_acked: proof_acked__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                    signer: signer__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.MsgAcknowledgement",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgAcknowledgementResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.result != 0 {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.MsgAcknowledgementResponse", len)?;
+        if self.result != 0 {
+            let v = ResponseResultType::try_from(self.result).map_err(|_| {
+                serde::ser::Error::custom(format!("Invalid variant {}", self.result))
+            })?;
+            struct_ser.serialize_field("result", &v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgAcknowledgementResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["result"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Result,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "result" => Ok(GeneratedField::Result),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgAcknowledgementResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.MsgAcknowledgementResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgAcknowledgementResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut result__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Result => {
+                            if result__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("result"));
+                            }
+                            result__ = Some(map_.next_value::<ResponseResultType>()? as i32);
+                        }
+                    }
+                }
+                Ok(MsgAcknowledgementResponse {
+                    result: result__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.MsgAcknowledgementResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgChannelCloseConfirm {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if !self.proof_init.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        if !self.signer.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.MsgChannelCloseConfirm", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if !self.proof_init.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "proofInit",
+                pbjson::private::base64::encode(&self.proof_init).as_str(),
+            )?;
+        }
+        if let Some(v) = self.proof_height.as_ref() {
+            struct_ser.serialize_field("proofHeight", v)?;
+        }
+        if !self.signer.is_empty() {
+            struct_ser.serialize_field("signer", &self.signer)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgChannelCloseConfirm {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "port_id",
+            "portId",
+            "channel_id",
+            "channelId",
+            "proof_init",
+            "proofInit",
+            "proof_height",
+            "proofHeight",
+            "signer",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+            ProofInit,
+            ProofHeight,
+            Signer,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "proofInit" | "proof_init" => Ok(GeneratedField::ProofInit),
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            "signer" => Ok(GeneratedField::Signer),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgChannelCloseConfirm;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.MsgChannelCloseConfirm")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgChannelCloseConfirm, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                let mut proof_init__ = None;
+                let mut proof_height__ = None;
+                let mut signer__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ProofInit => {
+                            if proof_init__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofInit"));
+                            }
+                            proof_init__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::ProofHeight => {
+                            if proof_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofHeight"));
+                            }
+                            proof_height__ = map_.next_value()?;
+                        }
+                        GeneratedField::Signer => {
+                            if signer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signer"));
+                            }
+                            signer__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgChannelCloseConfirm {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                    proof_init: proof_init__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                    signer: signer__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.MsgChannelCloseConfirm",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgChannelCloseConfirmResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser = serializer
+            .serialize_struct("ibc.core.channel.v1.MsgChannelCloseConfirmResponse", len)?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgChannelCloseConfirmResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgChannelCloseConfirmResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.MsgChannelCloseConfirmResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgChannelCloseConfirmResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(MsgChannelCloseConfirmResponse {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.MsgChannelCloseConfirmResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgChannelCloseInit {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if !self.signer.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.MsgChannelCloseInit", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if !self.signer.is_empty() {
+            struct_ser.serialize_field("signer", &self.signer)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgChannelCloseInit {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["port_id", "portId", "channel_id", "channelId", "signer"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+            Signer,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "signer" => Ok(GeneratedField::Signer),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgChannelCloseInit;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.MsgChannelCloseInit")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MsgChannelCloseInit, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                let mut signer__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Signer => {
+                            if signer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signer"));
+                            }
+                            signer__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgChannelCloseInit {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                    signer: signer__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.MsgChannelCloseInit",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgChannelCloseInitResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.MsgChannelCloseInitResponse", len)?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgChannelCloseInitResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgChannelCloseInitResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.MsgChannelCloseInitResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgChannelCloseInitResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(MsgChannelCloseInitResponse {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.MsgChannelCloseInitResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgChannelOpenAck {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if !self.counterparty_channel_id.is_empty() {
+            len += 1;
+        }
+        if !self.counterparty_version.is_empty() {
+            len += 1;
+        }
+        if !self.proof_try.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        if !self.signer.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.MsgChannelOpenAck", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if !self.counterparty_channel_id.is_empty() {
+            struct_ser.serialize_field("counterpartyChannelId", &self.counterparty_channel_id)?;
+        }
+        if !self.counterparty_version.is_empty() {
+            struct_ser.serialize_field("counterpartyVersion", &self.counterparty_version)?;
+        }
+        if !self.proof_try.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "proofTry",
+                pbjson::private::base64::encode(&self.proof_try).as_str(),
+            )?;
+        }
+        if let Some(v) = self.proof_height.as_ref() {
+            struct_ser.serialize_field("proofHeight", v)?;
+        }
+        if !self.signer.is_empty() {
+            struct_ser.serialize_field("signer", &self.signer)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgChannelOpenAck {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "port_id",
+            "portId",
+            "channel_id",
+            "channelId",
+            "counterparty_channel_id",
+            "counterpartyChannelId",
+            "counterparty_version",
+            "counterpartyVersion",
+            "proof_try",
+            "proofTry",
+            "proof_height",
+            "proofHeight",
+            "signer",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+            CounterpartyChannelId,
+            CounterpartyVersion,
+            ProofTry,
+            ProofHeight,
+            Signer,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "counterpartyChannelId" | "counterparty_channel_id" => {
+                                Ok(GeneratedField::CounterpartyChannelId)
+                            }
+                            "counterpartyVersion" | "counterparty_version" => {
+                                Ok(GeneratedField::CounterpartyVersion)
+                            }
+                            "proofTry" | "proof_try" => Ok(GeneratedField::ProofTry),
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            "signer" => Ok(GeneratedField::Signer),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgChannelOpenAck;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.MsgChannelOpenAck")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MsgChannelOpenAck, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                let mut counterparty_channel_id__ = None;
+                let mut counterparty_version__ = None;
+                let mut proof_try__ = None;
+                let mut proof_height__ = None;
+                let mut signer__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::CounterpartyChannelId => {
+                            if counterparty_channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "counterpartyChannelId",
+                                ));
+                            }
+                            counterparty_channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::CounterpartyVersion => {
+                            if counterparty_version__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "counterpartyVersion",
+                                ));
+                            }
+                            counterparty_version__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ProofTry => {
+                            if proof_try__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofTry"));
+                            }
+                            proof_try__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::ProofHeight => {
+                            if proof_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofHeight"));
+                            }
+                            proof_height__ = map_.next_value()?;
+                        }
+                        GeneratedField::Signer => {
+                            if signer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signer"));
+                            }
+                            signer__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgChannelOpenAck {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                    counterparty_channel_id: counterparty_channel_id__.unwrap_or_default(),
+                    counterparty_version: counterparty_version__.unwrap_or_default(),
+                    proof_try: proof_try__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                    signer: signer__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.MsgChannelOpenAck",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgChannelOpenAckResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.MsgChannelOpenAckResponse", len)?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgChannelOpenAckResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgChannelOpenAckResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.MsgChannelOpenAckResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgChannelOpenAckResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(MsgChannelOpenAckResponse {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.MsgChannelOpenAckResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgChannelOpenConfirm {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if !self.proof_ack.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        if !self.signer.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.MsgChannelOpenConfirm", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if !self.proof_ack.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "proofAck",
+                pbjson::private::base64::encode(&self.proof_ack).as_str(),
+            )?;
+        }
+        if let Some(v) = self.proof_height.as_ref() {
+            struct_ser.serialize_field("proofHeight", v)?;
+        }
+        if !self.signer.is_empty() {
+            struct_ser.serialize_field("signer", &self.signer)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgChannelOpenConfirm {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "port_id",
+            "portId",
+            "channel_id",
+            "channelId",
+            "proof_ack",
+            "proofAck",
+            "proof_height",
+            "proofHeight",
+            "signer",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+            ProofAck,
+            ProofHeight,
+            Signer,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "proofAck" | "proof_ack" => Ok(GeneratedField::ProofAck),
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            "signer" => Ok(GeneratedField::Signer),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgChannelOpenConfirm;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.MsgChannelOpenConfirm")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgChannelOpenConfirm, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                let mut proof_ack__ = None;
+                let mut proof_height__ = None;
+                let mut signer__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ProofAck => {
+                            if proof_ack__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofAck"));
+                            }
+                            proof_ack__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::ProofHeight => {
+                            if proof_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofHeight"));
+                            }
+                            proof_height__ = map_.next_value()?;
+                        }
+                        GeneratedField::Signer => {
+                            if signer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signer"));
+                            }
+                            signer__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgChannelOpenConfirm {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                    proof_ack: proof_ack__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                    signer: signer__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.MsgChannelOpenConfirm",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgChannelOpenConfirmResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser = serializer
+            .serialize_struct("ibc.core.channel.v1.MsgChannelOpenConfirmResponse", len)?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgChannelOpenConfirmResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgChannelOpenConfirmResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.MsgChannelOpenConfirmResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgChannelOpenConfirmResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(MsgChannelOpenConfirmResponse {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.MsgChannelOpenConfirmResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgChannelOpenInit {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if self.channel.is_some() {
+            len += 1;
+        }
+        if !self.signer.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.MsgChannelOpenInit", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if let Some(v) = self.channel.as_ref() {
+            struct_ser.serialize_field("channel", v)?;
+        }
+        if !self.signer.is_empty() {
+            struct_ser.serialize_field("signer", &self.signer)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgChannelOpenInit {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["port_id", "portId", "channel", "signer"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            Channel,
+            Signer,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channel" => Ok(GeneratedField::Channel),
+                            "signer" => Ok(GeneratedField::Signer),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgChannelOpenInit;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.MsgChannelOpenInit")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MsgChannelOpenInit, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel__ = None;
+                let mut signer__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Channel => {
+                            if channel__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channel"));
+                            }
+                            channel__ = map_.next_value()?;
+                        }
+                        GeneratedField::Signer => {
+                            if signer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signer"));
+                            }
+                            signer__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgChannelOpenInit {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel: channel__,
+                    signer: signer__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.MsgChannelOpenInit",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgChannelOpenInitResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if !self.version.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.MsgChannelOpenInitResponse", len)?;
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if !self.version.is_empty() {
+            struct_ser.serialize_field("version", &self.version)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgChannelOpenInitResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["channel_id", "channelId", "version"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ChannelId,
+            Version,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "version" => Ok(GeneratedField::Version),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgChannelOpenInitResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.MsgChannelOpenInitResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgChannelOpenInitResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut channel_id__ = None;
+                let mut version__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Version => {
+                            if version__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("version"));
+                            }
+                            version__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgChannelOpenInitResponse {
+                    channel_id: channel_id__.unwrap_or_default(),
+                    version: version__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.MsgChannelOpenInitResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgChannelOpenTry {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.previous_channel_id.is_empty() {
+            len += 1;
+        }
+        if self.channel.is_some() {
+            len += 1;
+        }
+        if !self.counterparty_version.is_empty() {
+            len += 1;
+        }
+        if !self.proof_init.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        if !self.signer.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.MsgChannelOpenTry", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.previous_channel_id.is_empty() {
+            struct_ser.serialize_field("previousChannelId", &self.previous_channel_id)?;
+        }
+        if let Some(v) = self.channel.as_ref() {
+            struct_ser.serialize_field("channel", v)?;
+        }
+        if !self.counterparty_version.is_empty() {
+            struct_ser.serialize_field("counterpartyVersion", &self.counterparty_version)?;
+        }
+        if !self.proof_init.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "proofInit",
+                pbjson::private::base64::encode(&self.proof_init).as_str(),
+            )?;
+        }
+        if let Some(v) = self.proof_height.as_ref() {
+            struct_ser.serialize_field("proofHeight", v)?;
+        }
+        if !self.signer.is_empty() {
+            struct_ser.serialize_field("signer", &self.signer)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgChannelOpenTry {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "port_id",
+            "portId",
+            "previous_channel_id",
+            "previousChannelId",
+            "channel",
+            "counterparty_version",
+            "counterpartyVersion",
+            "proof_init",
+            "proofInit",
+            "proof_height",
+            "proofHeight",
+            "signer",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            PreviousChannelId,
+            Channel,
+            CounterpartyVersion,
+            ProofInit,
+            ProofHeight,
+            Signer,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "previousChannelId" | "previous_channel_id" => {
+                                Ok(GeneratedField::PreviousChannelId)
+                            }
+                            "channel" => Ok(GeneratedField::Channel),
+                            "counterpartyVersion" | "counterparty_version" => {
+                                Ok(GeneratedField::CounterpartyVersion)
+                            }
+                            "proofInit" | "proof_init" => Ok(GeneratedField::ProofInit),
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            "signer" => Ok(GeneratedField::Signer),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgChannelOpenTry;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.MsgChannelOpenTry")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MsgChannelOpenTry, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut previous_channel_id__ = None;
+                let mut channel__ = None;
+                let mut counterparty_version__ = None;
+                let mut proof_init__ = None;
+                let mut proof_height__ = None;
+                let mut signer__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::PreviousChannelId => {
+                            if previous_channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("previousChannelId"));
+                            }
+                            previous_channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Channel => {
+                            if channel__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channel"));
+                            }
+                            channel__ = map_.next_value()?;
+                        }
+                        GeneratedField::CounterpartyVersion => {
+                            if counterparty_version__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "counterpartyVersion",
+                                ));
+                            }
+                            counterparty_version__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ProofInit => {
+                            if proof_init__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofInit"));
+                            }
+                            proof_init__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::ProofHeight => {
+                            if proof_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofHeight"));
+                            }
+                            proof_height__ = map_.next_value()?;
+                        }
+                        GeneratedField::Signer => {
+                            if signer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signer"));
+                            }
+                            signer__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgChannelOpenTry {
+                    port_id: port_id__.unwrap_or_default(),
+                    previous_channel_id: previous_channel_id__.unwrap_or_default(),
+                    channel: channel__,
+                    counterparty_version: counterparty_version__.unwrap_or_default(),
+                    proof_init: proof_init__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                    signer: signer__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.MsgChannelOpenTry",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgChannelOpenTryResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.version.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.MsgChannelOpenTryResponse", len)?;
+        if !self.version.is_empty() {
+            struct_ser.serialize_field("version", &self.version)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgChannelOpenTryResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["version"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Version,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "version" => Ok(GeneratedField::Version),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgChannelOpenTryResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.MsgChannelOpenTryResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgChannelOpenTryResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut version__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Version => {
+                            if version__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("version"));
+                            }
+                            version__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgChannelOpenTryResponse {
+                    version: version__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.MsgChannelOpenTryResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgRecvPacket {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.packet.is_some() {
+            len += 1;
+        }
+        if !self.proof_commitment.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        if !self.signer.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.MsgRecvPacket", len)?;
+        if let Some(v) = self.packet.as_ref() {
+            struct_ser.serialize_field("packet", v)?;
+        }
+        if !self.proof_commitment.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "proofCommitment",
+                pbjson::private::base64::encode(&self.proof_commitment).as_str(),
+            )?;
+        }
+        if let Some(v) = self.proof_height.as_ref() {
+            struct_ser.serialize_field("proofHeight", v)?;
+        }
+        if !self.signer.is_empty() {
+            struct_ser.serialize_field("signer", &self.signer)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgRecvPacket {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "packet",
+            "proof_commitment",
+            "proofCommitment",
+            "proof_height",
+            "proofHeight",
+            "signer",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Packet,
+            ProofCommitment,
+            ProofHeight,
+            Signer,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "packet" => Ok(GeneratedField::Packet),
+                            "proofCommitment" | "proof_commitment" => {
+                                Ok(GeneratedField::ProofCommitment)
+                            }
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            "signer" => Ok(GeneratedField::Signer),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgRecvPacket;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.MsgRecvPacket")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MsgRecvPacket, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut packet__ = None;
+                let mut proof_commitment__ = None;
+                let mut proof_height__ = None;
+                let mut signer__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Packet => {
+                            if packet__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("packet"));
+                            }
+                            packet__ = map_.next_value()?;
+                        }
+                        GeneratedField::ProofCommitment => {
+                            if proof_commitment__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofCommitment"));
+                            }
+                            proof_commitment__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::ProofHeight => {
+                            if proof_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofHeight"));
+                            }
+                            proof_height__ = map_.next_value()?;
+                        }
+                        GeneratedField::Signer => {
+                            if signer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signer"));
+                            }
+                            signer__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgRecvPacket {
+                    packet: packet__,
+                    proof_commitment: proof_commitment__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                    signer: signer__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.MsgRecvPacket",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgRecvPacketResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.result != 0 {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.MsgRecvPacketResponse", len)?;
+        if self.result != 0 {
+            let v = ResponseResultType::try_from(self.result).map_err(|_| {
+                serde::ser::Error::custom(format!("Invalid variant {}", self.result))
+            })?;
+            struct_ser.serialize_field("result", &v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgRecvPacketResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["result"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Result,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "result" => Ok(GeneratedField::Result),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgRecvPacketResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.MsgRecvPacketResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgRecvPacketResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut result__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Result => {
+                            if result__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("result"));
+                            }
+                            result__ = Some(map_.next_value::<ResponseResultType>()? as i32);
+                        }
+                    }
+                }
+                Ok(MsgRecvPacketResponse {
+                    result: result__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.MsgRecvPacketResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgTimeout {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.packet.is_some() {
+            len += 1;
+        }
+        if !self.proof_unreceived.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        if self.next_sequence_recv != 0 {
+            len += 1;
+        }
+        if !self.signer.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgTimeout", len)?;
+        if let Some(v) = self.packet.as_ref() {
+            struct_ser.serialize_field("packet", v)?;
+        }
+        if !self.proof_unreceived.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "proofUnreceived",
+                pbjson::private::base64::encode(&self.proof_unreceived).as_str(),
+            )?;
+        }
+        if let Some(v) = self.proof_height.as_ref() {
+            struct_ser.serialize_field("proofHeight", v)?;
+        }
+        if self.next_sequence_recv != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "nextSequenceRecv",
+                ToString::to_string(&self.next_sequence_recv).as_str(),
+            )?;
+        }
+        if !self.signer.is_empty() {
+            struct_ser.serialize_field("signer", &self.signer)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgTimeout {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "packet",
+            "proof_unreceived",
+            "proofUnreceived",
+            "proof_height",
+            "proofHeight",
+            "next_sequence_recv",
+            "nextSequenceRecv",
+            "signer",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Packet,
+            ProofUnreceived,
+            ProofHeight,
+            NextSequenceRecv,
+            Signer,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "packet" => Ok(GeneratedField::Packet),
+                            "proofUnreceived" | "proof_unreceived" => {
+                                Ok(GeneratedField::ProofUnreceived)
+                            }
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            "nextSequenceRecv" | "next_sequence_recv" => {
+                                Ok(GeneratedField::NextSequenceRecv)
+                            }
+                            "signer" => Ok(GeneratedField::Signer),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgTimeout;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.MsgTimeout")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MsgTimeout, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut packet__ = None;
+                let mut proof_unreceived__ = None;
+                let mut proof_height__ = None;
+                let mut next_sequence_recv__ = None;
+                let mut signer__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Packet => {
+                            if packet__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("packet"));
+                            }
+                            packet__ = map_.next_value()?;
+                        }
+                        GeneratedField::ProofUnreceived => {
+                            if proof_unreceived__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofUnreceived"));
+                            }
+                            proof_unreceived__ = 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::NextSequenceRecv => {
+                            if next_sequence_recv__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("nextSequenceRecv"));
+                            }
+                            next_sequence_recv__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Signer => {
+                            if signer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signer"));
+                            }
+                            signer__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgTimeout {
+                    packet: packet__,
+                    proof_unreceived: proof_unreceived__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                    next_sequence_recv: next_sequence_recv__.unwrap_or_default(),
+                    signer: signer__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("ibc.core.channel.v1.MsgTimeout", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgTimeoutOnClose {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.packet.is_some() {
+            len += 1;
+        }
+        if !self.proof_unreceived.is_empty() {
+            len += 1;
+        }
+        if !self.proof_close.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        if self.next_sequence_recv != 0 {
+            len += 1;
+        }
+        if !self.signer.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.MsgTimeoutOnClose", len)?;
+        if let Some(v) = self.packet.as_ref() {
+            struct_ser.serialize_field("packet", v)?;
+        }
+        if !self.proof_unreceived.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "proofUnreceived",
+                pbjson::private::base64::encode(&self.proof_unreceived).as_str(),
+            )?;
+        }
+        if !self.proof_close.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "proofClose",
+                pbjson::private::base64::encode(&self.proof_close).as_str(),
+            )?;
+        }
+        if let Some(v) = self.proof_height.as_ref() {
+            struct_ser.serialize_field("proofHeight", v)?;
+        }
+        if self.next_sequence_recv != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "nextSequenceRecv",
+                ToString::to_string(&self.next_sequence_recv).as_str(),
+            )?;
+        }
+        if !self.signer.is_empty() {
+            struct_ser.serialize_field("signer", &self.signer)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgTimeoutOnClose {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "packet",
+            "proof_unreceived",
+            "proofUnreceived",
+            "proof_close",
+            "proofClose",
+            "proof_height",
+            "proofHeight",
+            "next_sequence_recv",
+            "nextSequenceRecv",
+            "signer",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Packet,
+            ProofUnreceived,
+            ProofClose,
+            ProofHeight,
+            NextSequenceRecv,
+            Signer,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "packet" => Ok(GeneratedField::Packet),
+                            "proofUnreceived" | "proof_unreceived" => {
+                                Ok(GeneratedField::ProofUnreceived)
+                            }
+                            "proofClose" | "proof_close" => Ok(GeneratedField::ProofClose),
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            "nextSequenceRecv" | "next_sequence_recv" => {
+                                Ok(GeneratedField::NextSequenceRecv)
+                            }
+                            "signer" => Ok(GeneratedField::Signer),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgTimeoutOnClose;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.MsgTimeoutOnClose")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MsgTimeoutOnClose, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut packet__ = None;
+                let mut proof_unreceived__ = None;
+                let mut proof_close__ = None;
+                let mut proof_height__ = None;
+                let mut next_sequence_recv__ = None;
+                let mut signer__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Packet => {
+                            if packet__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("packet"));
+                            }
+                            packet__ = map_.next_value()?;
+                        }
+                        GeneratedField::ProofUnreceived => {
+                            if proof_unreceived__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofUnreceived"));
+                            }
+                            proof_unreceived__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::ProofClose => {
+                            if proof_close__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofClose"));
+                            }
+                            proof_close__ = 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::NextSequenceRecv => {
+                            if next_sequence_recv__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("nextSequenceRecv"));
+                            }
+                            next_sequence_recv__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Signer => {
+                            if signer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signer"));
+                            }
+                            signer__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgTimeoutOnClose {
+                    packet: packet__,
+                    proof_unreceived: proof_unreceived__.unwrap_or_default(),
+                    proof_close: proof_close__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                    next_sequence_recv: next_sequence_recv__.unwrap_or_default(),
+                    signer: signer__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.MsgTimeoutOnClose",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgTimeoutOnCloseResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.result != 0 {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.MsgTimeoutOnCloseResponse", len)?;
+        if self.result != 0 {
+            let v = ResponseResultType::try_from(self.result).map_err(|_| {
+                serde::ser::Error::custom(format!("Invalid variant {}", self.result))
+            })?;
+            struct_ser.serialize_field("result", &v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgTimeoutOnCloseResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["result"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Result,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "result" => Ok(GeneratedField::Result),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgTimeoutOnCloseResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.MsgTimeoutOnCloseResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgTimeoutOnCloseResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut result__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Result => {
+                            if result__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("result"));
+                            }
+                            result__ = Some(map_.next_value::<ResponseResultType>()? as i32);
+                        }
+                    }
+                }
+                Ok(MsgTimeoutOnCloseResponse {
+                    result: result__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.MsgTimeoutOnCloseResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgTimeoutResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.result != 0 {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.MsgTimeoutResponse", len)?;
+        if self.result != 0 {
+            let v = ResponseResultType::try_from(self.result).map_err(|_| {
+                serde::ser::Error::custom(format!("Invalid variant {}", self.result))
+            })?;
+            struct_ser.serialize_field("result", &v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgTimeoutResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["result"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Result,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "result" => Ok(GeneratedField::Result),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgTimeoutResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.MsgTimeoutResponse")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MsgTimeoutResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut result__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Result => {
+                            if result__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("result"));
+                            }
+                            result__ = Some(map_.next_value::<ResponseResultType>()? as i32);
+                        }
+                    }
+                }
+                Ok(MsgTimeoutResponse {
+                    result: result__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.MsgTimeoutResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Order {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::NoneUnspecified => "ORDER_NONE_UNSPECIFIED",
+            Self::Unordered => "ORDER_UNORDERED",
+            Self::Ordered => "ORDER_ORDERED",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Order {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["ORDER_NONE_UNSPECIFIED", "ORDER_UNORDERED", "ORDER_ORDERED"];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Order;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                i32::try_from(v)
+                    .ok()
+                    .and_then(|x| x.try_into().ok())
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                i32::try_from(v)
+                    .ok()
+                    .and_then(|x| x.try_into().ok())
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "ORDER_NONE_UNSPECIFIED" => Ok(Order::NoneUnspecified),
+                    "ORDER_UNORDERED" => Ok(Order::Unordered),
+                    "ORDER_ORDERED" => Ok(Order::Ordered),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Packet {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.sequence != 0 {
+            len += 1;
+        }
+        if !self.source_port.is_empty() {
+            len += 1;
+        }
+        if !self.source_channel.is_empty() {
+            len += 1;
+        }
+        if !self.destination_port.is_empty() {
+            len += 1;
+        }
+        if !self.destination_channel.is_empty() {
+            len += 1;
+        }
+        if !self.data.is_empty() {
+            len += 1;
+        }
+        if self.timeout_height.is_some() {
+            len += 1;
+        }
+        if self.timeout_timestamp != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.Packet", len)?;
+        if self.sequence != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("sequence", ToString::to_string(&self.sequence).as_str())?;
+        }
+        if !self.source_port.is_empty() {
+            struct_ser.serialize_field("sourcePort", &self.source_port)?;
+        }
+        if !self.source_channel.is_empty() {
+            struct_ser.serialize_field("sourceChannel", &self.source_channel)?;
+        }
+        if !self.destination_port.is_empty() {
+            struct_ser.serialize_field("destinationPort", &self.destination_port)?;
+        }
+        if !self.destination_channel.is_empty() {
+            struct_ser.serialize_field("destinationChannel", &self.destination_channel)?;
+        }
+        if !self.data.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?;
+        }
+        if let Some(v) = self.timeout_height.as_ref() {
+            struct_ser.serialize_field("timeoutHeight", v)?;
+        }
+        if self.timeout_timestamp != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "timeoutTimestamp",
+                ToString::to_string(&self.timeout_timestamp).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Packet {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "sequence",
+            "source_port",
+            "sourcePort",
+            "source_channel",
+            "sourceChannel",
+            "destination_port",
+            "destinationPort",
+            "destination_channel",
+            "destinationChannel",
+            "data",
+            "timeout_height",
+            "timeoutHeight",
+            "timeout_timestamp",
+            "timeoutTimestamp",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Sequence,
+            SourcePort,
+            SourceChannel,
+            DestinationPort,
+            DestinationChannel,
+            Data,
+            TimeoutHeight,
+            TimeoutTimestamp,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "sequence" => Ok(GeneratedField::Sequence),
+                            "sourcePort" | "source_port" => Ok(GeneratedField::SourcePort),
+                            "sourceChannel" | "source_channel" => Ok(GeneratedField::SourceChannel),
+                            "destinationPort" | "destination_port" => {
+                                Ok(GeneratedField::DestinationPort)
+                            }
+                            "destinationChannel" | "destination_channel" => {
+                                Ok(GeneratedField::DestinationChannel)
+                            }
+                            "data" => Ok(GeneratedField::Data),
+                            "timeoutHeight" | "timeout_height" => Ok(GeneratedField::TimeoutHeight),
+                            "timeoutTimestamp" | "timeout_timestamp" => {
+                                Ok(GeneratedField::TimeoutTimestamp)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Packet;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.Packet")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Packet, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut sequence__ = None;
+                let mut source_port__ = None;
+                let mut source_channel__ = None;
+                let mut destination_port__ = None;
+                let mut destination_channel__ = None;
+                let mut data__ = None;
+                let mut timeout_height__ = None;
+                let mut timeout_timestamp__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Sequence => {
+                            if sequence__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sequence"));
+                            }
+                            sequence__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::SourcePort => {
+                            if source_port__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sourcePort"));
+                            }
+                            source_port__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::SourceChannel => {
+                            if source_channel__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sourceChannel"));
+                            }
+                            source_channel__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::DestinationPort => {
+                            if destination_port__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("destinationPort"));
+                            }
+                            destination_port__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::DestinationChannel => {
+                            if destination_channel__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "destinationChannel",
+                                ));
+                            }
+                            destination_channel__ = 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,
+                            );
+                        }
+                        GeneratedField::TimeoutHeight => {
+                            if timeout_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timeoutHeight"));
+                            }
+                            timeout_height__ = map_.next_value()?;
+                        }
+                        GeneratedField::TimeoutTimestamp => {
+                            if timeout_timestamp__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timeoutTimestamp"));
+                            }
+                            timeout_timestamp__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(Packet {
+                    sequence: sequence__.unwrap_or_default(),
+                    source_port: source_port__.unwrap_or_default(),
+                    source_channel: source_channel__.unwrap_or_default(),
+                    destination_port: destination_port__.unwrap_or_default(),
+                    destination_channel: destination_channel__.unwrap_or_default(),
+                    data: data__.unwrap_or_default(),
+                    timeout_height: timeout_height__,
+                    timeout_timestamp: timeout_timestamp__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("ibc.core.channel.v1.Packet", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for PacketId {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if self.sequence != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.PacketId", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if self.sequence != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("sequence", ToString::to_string(&self.sequence).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for PacketId {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["port_id", "portId", "channel_id", "channelId", "sequence"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+            Sequence,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "sequence" => Ok(GeneratedField::Sequence),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PacketId;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.PacketId")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PacketId, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                let mut sequence__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Sequence => {
+                            if sequence__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sequence"));
+                            }
+                            sequence__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(PacketId {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                    sequence: sequence__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("ibc.core.channel.v1.PacketId", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for PacketSequence {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if self.sequence != 0 {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.PacketSequence", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if self.sequence != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("sequence", ToString::to_string(&self.sequence).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for PacketSequence {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["port_id", "portId", "channel_id", "channelId", "sequence"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+            Sequence,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "sequence" => Ok(GeneratedField::Sequence),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PacketSequence;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.PacketSequence")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PacketSequence, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                let mut sequence__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Sequence => {
+                            if sequence__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sequence"));
+                            }
+                            sequence__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(PacketSequence {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                    sequence: sequence__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.PacketSequence",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for PacketState {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if self.sequence != 0 {
+            len += 1;
+        }
+        if !self.data.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.PacketState", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if self.sequence != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("sequence", ToString::to_string(&self.sequence).as_str())?;
+        }
+        if !self.data.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for PacketState {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "port_id",
+            "portId",
+            "channel_id",
+            "channelId",
+            "sequence",
+            "data",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+            Sequence,
+            Data,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "sequence" => Ok(GeneratedField::Sequence),
+                            "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 = PacketState;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.PacketState")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PacketState, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                let mut sequence__ = None;
+                let mut data__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Sequence => {
+                            if sequence__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sequence"));
+                            }
+                            sequence__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Data => {
+                            if data__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("data"));
+                            }
+                            data__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(PacketState {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                    sequence: sequence__.unwrap_or_default(),
+                    data: data__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("ibc.core.channel.v1.PacketState", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryChannelClientStateRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.core.channel.v1.QueryChannelClientStateRequest", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryChannelClientStateRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["port_id", "portId", "channel_id", "channelId"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryChannelClientStateRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryChannelClientStateRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryChannelClientStateRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryChannelClientStateRequest {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryChannelClientStateRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryChannelClientStateResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.identified_client_state.is_some() {
+            len += 1;
+        }
+        if !self.proof.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.core.channel.v1.QueryChannelClientStateResponse", len)?;
+        if let Some(v) = self.identified_client_state.as_ref() {
+            struct_ser.serialize_field("identifiedClientState", v)?;
+        }
+        if !self.proof.is_empty() {
+            #[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)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryChannelClientStateResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "identified_client_state",
+            "identifiedClientState",
+            "proof",
+            "proof_height",
+            "proofHeight",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            IdentifiedClientState,
+            Proof,
+            ProofHeight,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "identifiedClientState" | "identified_client_state" => {
+                                Ok(GeneratedField::IdentifiedClientState)
+                            }
+                            "proof" => Ok(GeneratedField::Proof),
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryChannelClientStateResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryChannelClientStateResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryChannelClientStateResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut identified_client_state__ = None;
+                let mut proof__ = None;
+                let mut proof_height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::IdentifiedClientState => {
+                            if identified_client_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "identifiedClientState",
+                                ));
+                            }
+                            identified_client_state__ = 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()?;
+                        }
+                    }
+                }
+                Ok(QueryChannelClientStateResponse {
+                    identified_client_state: identified_client_state__,
+                    proof: proof__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryChannelClientStateResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryChannelConsensusStateRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if self.revision_number != 0 {
+            len += 1;
+        }
+        if self.revision_height != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.core.channel.v1.QueryChannelConsensusStateRequest", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if self.revision_number != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "revisionNumber",
+                ToString::to_string(&self.revision_number).as_str(),
+            )?;
+        }
+        if self.revision_height != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "revisionHeight",
+                ToString::to_string(&self.revision_height).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryChannelConsensusStateRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "port_id",
+            "portId",
+            "channel_id",
+            "channelId",
+            "revision_number",
+            "revisionNumber",
+            "revision_height",
+            "revisionHeight",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+            RevisionNumber,
+            RevisionHeight,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "revisionNumber" | "revision_number" => {
+                                Ok(GeneratedField::RevisionNumber)
+                            }
+                            "revisionHeight" | "revision_height" => {
+                                Ok(GeneratedField::RevisionHeight)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryChannelConsensusStateRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryChannelConsensusStateRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryChannelConsensusStateRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                let mut revision_number__ = None;
+                let mut revision_height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::RevisionNumber => {
+                            if revision_number__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("revisionNumber"));
+                            }
+                            revision_number__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::RevisionHeight => {
+                            if revision_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("revisionHeight"));
+                            }
+                            revision_height__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(QueryChannelConsensusStateRequest {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                    revision_number: revision_number__.unwrap_or_default(),
+                    revision_height: revision_height__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryChannelConsensusStateRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryChannelConsensusStateResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.consensus_state.is_some() {
+            len += 1;
+        }
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        if !self.proof.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.core.channel.v1.QueryChannelConsensusStateResponse",
+            len,
+        )?;
+        if let Some(v) = self.consensus_state.as_ref() {
+            struct_ser.serialize_field("consensusState", v)?;
+        }
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        if !self.proof.is_empty() {
+            #[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)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryChannelConsensusStateResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "consensus_state",
+            "consensusState",
+            "client_id",
+            "clientId",
+            "proof",
+            "proof_height",
+            "proofHeight",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ConsensusState,
+            ClientId,
+            Proof,
+            ProofHeight,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "consensusState" | "consensus_state" => {
+                                Ok(GeneratedField::ConsensusState)
+                            }
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            "proof" => Ok(GeneratedField::Proof),
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryChannelConsensusStateResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryChannelConsensusStateResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryChannelConsensusStateResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut consensus_state__ = None;
+                let mut client_id__ = None;
+                let mut proof__ = None;
+                let mut proof_height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ConsensusState => {
+                            if consensus_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("consensusState"));
+                            }
+                            consensus_state__ = map_.next_value()?;
+                        }
+                        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()?;
+                        }
+                    }
+                }
+                Ok(QueryChannelConsensusStateResponse {
+                    consensus_state: consensus_state__,
+                    client_id: client_id__.unwrap_or_default(),
+                    proof: proof__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryChannelConsensusStateResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryChannelRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.QueryChannelRequest", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryChannelRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["port_id", "portId", "channel_id", "channelId"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryChannelRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryChannelRequest")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<QueryChannelRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryChannelRequest {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryChannelRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryChannelResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.channel.is_some() {
+            len += 1;
+        }
+        if !self.proof.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.QueryChannelResponse", len)?;
+        if let Some(v) = self.channel.as_ref() {
+            struct_ser.serialize_field("channel", v)?;
+        }
+        if !self.proof.is_empty() {
+            #[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)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryChannelResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["channel", "proof", "proof_height", "proofHeight"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Channel,
+            Proof,
+            ProofHeight,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "channel" => Ok(GeneratedField::Channel),
+                            "proof" => Ok(GeneratedField::Proof),
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryChannelResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryChannelResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryChannelResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut channel__ = None;
+                let mut proof__ = None;
+                let mut proof_height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Channel => {
+                            if channel__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channel"));
+                            }
+                            channel__ = 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()?;
+                        }
+                    }
+                }
+                Ok(QueryChannelResponse {
+                    channel: channel__,
+                    proof: proof__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryChannelResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryChannelsRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.pagination.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.QueryChannelsRequest", len)?;
+        if let Some(v) = self.pagination.as_ref() {
+            struct_ser.serialize_field("pagination", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryChannelsRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["pagination"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Pagination,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    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 = QueryChannelsRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryChannelsRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryChannelsRequest, V::Error>
+            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(QueryChannelsRequest {
+                    pagination: pagination__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryChannelsRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryChannelsResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.channels.is_empty() {
+            len += 1;
+        }
+        if self.pagination.is_some() {
+            len += 1;
+        }
+        if self.height.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.QueryChannelsResponse", len)?;
+        if !self.channels.is_empty() {
+            struct_ser.serialize_field("channels", &self.channels)?;
+        }
+        if let Some(v) = self.pagination.as_ref() {
+            struct_ser.serialize_field("pagination", v)?;
+        }
+        if let Some(v) = self.height.as_ref() {
+            struct_ser.serialize_field("height", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryChannelsResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["channels", "pagination", "height"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Channels,
+            Pagination,
+            Height,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "channels" => Ok(GeneratedField::Channels),
+                            "pagination" => Ok(GeneratedField::Pagination),
+                            "height" => Ok(GeneratedField::Height),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryChannelsResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryChannelsResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryChannelsResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut channels__ = None;
+                let mut pagination__ = None;
+                let mut height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Channels => {
+                            if channels__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channels"));
+                            }
+                            channels__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Pagination => {
+                            if pagination__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("pagination"));
+                            }
+                            pagination__ = map_.next_value()?;
+                        }
+                        GeneratedField::Height => {
+                            if height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("height"));
+                            }
+                            height__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryChannelsResponse {
+                    channels: channels__.unwrap_or_default(),
+                    pagination: pagination__,
+                    height: height__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryChannelsResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryConnectionChannelsRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.connection.is_empty() {
+            len += 1;
+        }
+        if self.pagination.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.core.channel.v1.QueryConnectionChannelsRequest", len)?;
+        if !self.connection.is_empty() {
+            struct_ser.serialize_field("connection", &self.connection)?;
+        }
+        if let Some(v) = self.pagination.as_ref() {
+            struct_ser.serialize_field("pagination", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryConnectionChannelsRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["connection", "pagination"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Connection,
+            Pagination,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "connection" => Ok(GeneratedField::Connection),
+                            "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 = QueryConnectionChannelsRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryConnectionChannelsRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryConnectionChannelsRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut connection__ = None;
+                let mut pagination__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Connection => {
+                            if connection__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("connection"));
+                            }
+                            connection__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Pagination => {
+                            if pagination__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("pagination"));
+                            }
+                            pagination__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryConnectionChannelsRequest {
+                    connection: connection__.unwrap_or_default(),
+                    pagination: pagination__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryConnectionChannelsRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryConnectionChannelsResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.channels.is_empty() {
+            len += 1;
+        }
+        if self.pagination.is_some() {
+            len += 1;
+        }
+        if self.height.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.core.channel.v1.QueryConnectionChannelsResponse", len)?;
+        if !self.channels.is_empty() {
+            struct_ser.serialize_field("channels", &self.channels)?;
+        }
+        if let Some(v) = self.pagination.as_ref() {
+            struct_ser.serialize_field("pagination", v)?;
+        }
+        if let Some(v) = self.height.as_ref() {
+            struct_ser.serialize_field("height", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryConnectionChannelsResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["channels", "pagination", "height"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Channels,
+            Pagination,
+            Height,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "channels" => Ok(GeneratedField::Channels),
+                            "pagination" => Ok(GeneratedField::Pagination),
+                            "height" => Ok(GeneratedField::Height),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryConnectionChannelsResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryConnectionChannelsResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryConnectionChannelsResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut channels__ = None;
+                let mut pagination__ = None;
+                let mut height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Channels => {
+                            if channels__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channels"));
+                            }
+                            channels__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Pagination => {
+                            if pagination__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("pagination"));
+                            }
+                            pagination__ = map_.next_value()?;
+                        }
+                        GeneratedField::Height => {
+                            if height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("height"));
+                            }
+                            height__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryConnectionChannelsResponse {
+                    channels: channels__.unwrap_or_default(),
+                    pagination: pagination__,
+                    height: height__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryConnectionChannelsResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryNextSequenceReceiveRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.core.channel.v1.QueryNextSequenceReceiveRequest", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryNextSequenceReceiveRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["port_id", "portId", "channel_id", "channelId"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryNextSequenceReceiveRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryNextSequenceReceiveRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryNextSequenceReceiveRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryNextSequenceReceiveRequest {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryNextSequenceReceiveRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryNextSequenceReceiveResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.next_sequence_receive != 0 {
+            len += 1;
+        }
+        if !self.proof.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.core.channel.v1.QueryNextSequenceReceiveResponse", len)?;
+        if self.next_sequence_receive != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "nextSequenceReceive",
+                ToString::to_string(&self.next_sequence_receive).as_str(),
+            )?;
+        }
+        if !self.proof.is_empty() {
+            #[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)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryNextSequenceReceiveResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "next_sequence_receive",
+            "nextSequenceReceive",
+            "proof",
+            "proof_height",
+            "proofHeight",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            NextSequenceReceive,
+            Proof,
+            ProofHeight,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "nextSequenceReceive" | "next_sequence_receive" => {
+                                Ok(GeneratedField::NextSequenceReceive)
+                            }
+                            "proof" => Ok(GeneratedField::Proof),
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryNextSequenceReceiveResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryNextSequenceReceiveResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryNextSequenceReceiveResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut next_sequence_receive__ = None;
+                let mut proof__ = None;
+                let mut proof_height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::NextSequenceReceive => {
+                            if next_sequence_receive__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "nextSequenceReceive",
+                                ));
+                            }
+                            next_sequence_receive__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        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()?;
+                        }
+                    }
+                }
+                Ok(QueryNextSequenceReceiveResponse {
+                    next_sequence_receive: next_sequence_receive__.unwrap_or_default(),
+                    proof: proof__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryNextSequenceReceiveResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryPacketAcknowledgementRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if self.sequence != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.core.channel.v1.QueryPacketAcknowledgementRequest", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if self.sequence != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("sequence", ToString::to_string(&self.sequence).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["port_id", "portId", "channel_id", "channelId", "sequence"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+            Sequence,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "sequence" => Ok(GeneratedField::Sequence),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryPacketAcknowledgementRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryPacketAcknowledgementRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryPacketAcknowledgementRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                let mut sequence__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Sequence => {
+                            if sequence__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sequence"));
+                            }
+                            sequence__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(QueryPacketAcknowledgementRequest {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                    sequence: sequence__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryPacketAcknowledgementRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryPacketAcknowledgementResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.acknowledgement.is_empty() {
+            len += 1;
+        }
+        if !self.proof.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.core.channel.v1.QueryPacketAcknowledgementResponse",
+            len,
+        )?;
+        if !self.acknowledgement.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "acknowledgement",
+                pbjson::private::base64::encode(&self.acknowledgement).as_str(),
+            )?;
+        }
+        if !self.proof.is_empty() {
+            #[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)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["acknowledgement", "proof", "proof_height", "proofHeight"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Acknowledgement,
+            Proof,
+            ProofHeight,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "acknowledgement" => Ok(GeneratedField::Acknowledgement),
+                            "proof" => Ok(GeneratedField::Proof),
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryPacketAcknowledgementResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryPacketAcknowledgementResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryPacketAcknowledgementResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut acknowledgement__ = None;
+                let mut proof__ = None;
+                let mut proof_height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Acknowledgement => {
+                            if acknowledgement__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("acknowledgement"));
+                            }
+                            acknowledgement__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        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()?;
+                        }
+                    }
+                }
+                Ok(QueryPacketAcknowledgementResponse {
+                    acknowledgement: acknowledgement__.unwrap_or_default(),
+                    proof: proof__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryPacketAcknowledgementResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryPacketAcknowledgementsRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if self.pagination.is_some() {
+            len += 1;
+        }
+        if !self.packet_commitment_sequences.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.core.channel.v1.QueryPacketAcknowledgementsRequest",
+            len,
+        )?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if let Some(v) = self.pagination.as_ref() {
+            struct_ser.serialize_field("pagination", v)?;
+        }
+        if !self.packet_commitment_sequences.is_empty() {
+            struct_ser.serialize_field(
+                "packetCommitmentSequences",
+                &self
+                    .packet_commitment_sequences
+                    .iter()
+                    .map(ToString::to_string)
+                    .collect::<Vec<_>>(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementsRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "port_id",
+            "portId",
+            "channel_id",
+            "channelId",
+            "pagination",
+            "packet_commitment_sequences",
+            "packetCommitmentSequences",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+            Pagination,
+            PacketCommitmentSequences,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "pagination" => Ok(GeneratedField::Pagination),
+                            "packetCommitmentSequences" | "packet_commitment_sequences" => {
+                                Ok(GeneratedField::PacketCommitmentSequences)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryPacketAcknowledgementsRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryPacketAcknowledgementsRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryPacketAcknowledgementsRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                let mut pagination__ = None;
+                let mut packet_commitment_sequences__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Pagination => {
+                            if pagination__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("pagination"));
+                            }
+                            pagination__ = map_.next_value()?;
+                        }
+                        GeneratedField::PacketCommitmentSequences => {
+                            if packet_commitment_sequences__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "packetCommitmentSequences",
+                                ));
+                            }
+                            packet_commitment_sequences__ = Some(
+                                map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
+                                    .into_iter()
+                                    .map(|x| x.0)
+                                    .collect(),
+                            );
+                        }
+                    }
+                }
+                Ok(QueryPacketAcknowledgementsRequest {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                    pagination: pagination__,
+                    packet_commitment_sequences: packet_commitment_sequences__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryPacketAcknowledgementsRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryPacketAcknowledgementsResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.acknowledgements.is_empty() {
+            len += 1;
+        }
+        if self.pagination.is_some() {
+            len += 1;
+        }
+        if self.height.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.core.channel.v1.QueryPacketAcknowledgementsResponse",
+            len,
+        )?;
+        if !self.acknowledgements.is_empty() {
+            struct_ser.serialize_field("acknowledgements", &self.acknowledgements)?;
+        }
+        if let Some(v) = self.pagination.as_ref() {
+            struct_ser.serialize_field("pagination", v)?;
+        }
+        if let Some(v) = self.height.as_ref() {
+            struct_ser.serialize_field("height", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementsResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["acknowledgements", "pagination", "height"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Acknowledgements,
+            Pagination,
+            Height,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "acknowledgements" => Ok(GeneratedField::Acknowledgements),
+                            "pagination" => Ok(GeneratedField::Pagination),
+                            "height" => Ok(GeneratedField::Height),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryPacketAcknowledgementsResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter
+                    .write_str("struct ibc.core.channel.v1.QueryPacketAcknowledgementsResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryPacketAcknowledgementsResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut acknowledgements__ = None;
+                let mut pagination__ = None;
+                let mut height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Acknowledgements => {
+                            if acknowledgements__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("acknowledgements"));
+                            }
+                            acknowledgements__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Pagination => {
+                            if pagination__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("pagination"));
+                            }
+                            pagination__ = map_.next_value()?;
+                        }
+                        GeneratedField::Height => {
+                            if height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("height"));
+                            }
+                            height__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryPacketAcknowledgementsResponse {
+                    acknowledgements: acknowledgements__.unwrap_or_default(),
+                    pagination: pagination__,
+                    height: height__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryPacketAcknowledgementsResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryPacketCommitmentRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if self.sequence != 0 {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.QueryPacketCommitmentRequest", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if self.sequence != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("sequence", ToString::to_string(&self.sequence).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["port_id", "portId", "channel_id", "channelId", "sequence"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+            Sequence,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "sequence" => Ok(GeneratedField::Sequence),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryPacketCommitmentRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryPacketCommitmentRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryPacketCommitmentRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                let mut sequence__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Sequence => {
+                            if sequence__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sequence"));
+                            }
+                            sequence__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(QueryPacketCommitmentRequest {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                    sequence: sequence__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryPacketCommitmentRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryPacketCommitmentResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.commitment.is_empty() {
+            len += 1;
+        }
+        if !self.proof.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.core.channel.v1.QueryPacketCommitmentResponse", len)?;
+        if !self.commitment.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "commitment",
+                pbjson::private::base64::encode(&self.commitment).as_str(),
+            )?;
+        }
+        if !self.proof.is_empty() {
+            #[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)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["commitment", "proof", "proof_height", "proofHeight"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Commitment,
+            Proof,
+            ProofHeight,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "commitment" => Ok(GeneratedField::Commitment),
+                            "proof" => Ok(GeneratedField::Proof),
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryPacketCommitmentResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryPacketCommitmentResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryPacketCommitmentResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut commitment__ = None;
+                let mut proof__ = None;
+                let mut proof_height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Commitment => {
+                            if commitment__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("commitment"));
+                            }
+                            commitment__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        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()?;
+                        }
+                    }
+                }
+                Ok(QueryPacketCommitmentResponse {
+                    commitment: commitment__.unwrap_or_default(),
+                    proof: proof__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryPacketCommitmentResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryPacketCommitmentsRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if self.pagination.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.core.channel.v1.QueryPacketCommitmentsRequest", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if let Some(v) = self.pagination.as_ref() {
+            struct_ser.serialize_field("pagination", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentsRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["port_id", "portId", "channel_id", "channelId", "pagination"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+            Pagination,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "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 = QueryPacketCommitmentsRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryPacketCommitmentsRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryPacketCommitmentsRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                let mut pagination__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Pagination => {
+                            if pagination__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("pagination"));
+                            }
+                            pagination__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryPacketCommitmentsRequest {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                    pagination: pagination__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryPacketCommitmentsRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryPacketCommitmentsResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.commitments.is_empty() {
+            len += 1;
+        }
+        if self.pagination.is_some() {
+            len += 1;
+        }
+        if self.height.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.core.channel.v1.QueryPacketCommitmentsResponse", len)?;
+        if !self.commitments.is_empty() {
+            struct_ser.serialize_field("commitments", &self.commitments)?;
+        }
+        if let Some(v) = self.pagination.as_ref() {
+            struct_ser.serialize_field("pagination", v)?;
+        }
+        if let Some(v) = self.height.as_ref() {
+            struct_ser.serialize_field("height", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentsResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["commitments", "pagination", "height"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Commitments,
+            Pagination,
+            Height,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "commitments" => Ok(GeneratedField::Commitments),
+                            "pagination" => Ok(GeneratedField::Pagination),
+                            "height" => Ok(GeneratedField::Height),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryPacketCommitmentsResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryPacketCommitmentsResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryPacketCommitmentsResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut commitments__ = None;
+                let mut pagination__ = None;
+                let mut height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Commitments => {
+                            if commitments__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("commitments"));
+                            }
+                            commitments__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Pagination => {
+                            if pagination__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("pagination"));
+                            }
+                            pagination__ = map_.next_value()?;
+                        }
+                        GeneratedField::Height => {
+                            if height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("height"));
+                            }
+                            height__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryPacketCommitmentsResponse {
+                    commitments: commitments__.unwrap_or_default(),
+                    pagination: pagination__,
+                    height: height__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryPacketCommitmentsResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryPacketReceiptRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if self.sequence != 0 {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.QueryPacketReceiptRequest", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if self.sequence != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("sequence", ToString::to_string(&self.sequence).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryPacketReceiptRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["port_id", "portId", "channel_id", "channelId", "sequence"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+            Sequence,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "sequence" => Ok(GeneratedField::Sequence),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryPacketReceiptRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryPacketReceiptRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryPacketReceiptRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                let mut sequence__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Sequence => {
+                            if sequence__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sequence"));
+                            }
+                            sequence__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(QueryPacketReceiptRequest {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                    sequence: sequence__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryPacketReceiptRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryPacketReceiptResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.received {
+            len += 1;
+        }
+        if !self.proof.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.QueryPacketReceiptResponse", len)?;
+        if self.received {
+            struct_ser.serialize_field("received", &self.received)?;
+        }
+        if !self.proof.is_empty() {
+            #[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)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryPacketReceiptResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["received", "proof", "proof_height", "proofHeight"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Received,
+            Proof,
+            ProofHeight,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "received" => Ok(GeneratedField::Received),
+                            "proof" => Ok(GeneratedField::Proof),
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryPacketReceiptResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryPacketReceiptResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryPacketReceiptResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut received__ = None;
+                let mut proof__ = None;
+                let mut proof_height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Received => {
+                            if received__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("received"));
+                            }
+                            received__ = 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()?;
+                        }
+                    }
+                }
+                Ok(QueryPacketReceiptResponse {
+                    received: received__.unwrap_or_default(),
+                    proof: proof__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryPacketReceiptResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryUnreceivedAcksRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if !self.packet_ack_sequences.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.QueryUnreceivedAcksRequest", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if !self.packet_ack_sequences.is_empty() {
+            struct_ser.serialize_field(
+                "packetAckSequences",
+                &self
+                    .packet_ack_sequences
+                    .iter()
+                    .map(ToString::to_string)
+                    .collect::<Vec<_>>(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryUnreceivedAcksRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "port_id",
+            "portId",
+            "channel_id",
+            "channelId",
+            "packet_ack_sequences",
+            "packetAckSequences",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+            PacketAckSequences,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "packetAckSequences" | "packet_ack_sequences" => {
+                                Ok(GeneratedField::PacketAckSequences)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryUnreceivedAcksRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryUnreceivedAcksRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryUnreceivedAcksRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                let mut packet_ack_sequences__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::PacketAckSequences => {
+                            if packet_ack_sequences__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "packetAckSequences",
+                                ));
+                            }
+                            packet_ack_sequences__ = Some(
+                                map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
+                                    .into_iter()
+                                    .map(|x| x.0)
+                                    .collect(),
+                            );
+                        }
+                    }
+                }
+                Ok(QueryUnreceivedAcksRequest {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                    packet_ack_sequences: packet_ack_sequences__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryUnreceivedAcksRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryUnreceivedAcksResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.sequences.is_empty() {
+            len += 1;
+        }
+        if self.height.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.channel.v1.QueryUnreceivedAcksResponse", len)?;
+        if !self.sequences.is_empty() {
+            struct_ser.serialize_field(
+                "sequences",
+                &self
+                    .sequences
+                    .iter()
+                    .map(ToString::to_string)
+                    .collect::<Vec<_>>(),
+            )?;
+        }
+        if let Some(v) = self.height.as_ref() {
+            struct_ser.serialize_field("height", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryUnreceivedAcksResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["sequences", "height"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Sequences,
+            Height,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "sequences" => Ok(GeneratedField::Sequences),
+                            "height" => Ok(GeneratedField::Height),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryUnreceivedAcksResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryUnreceivedAcksResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryUnreceivedAcksResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut sequences__ = None;
+                let mut height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Sequences => {
+                            if sequences__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sequences"));
+                            }
+                            sequences__ = Some(
+                                map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
+                                    .into_iter()
+                                    .map(|x| x.0)
+                                    .collect(),
+                            );
+                        }
+                        GeneratedField::Height => {
+                            if height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("height"));
+                            }
+                            height__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryUnreceivedAcksResponse {
+                    sequences: sequences__.unwrap_or_default(),
+                    height: height__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryUnreceivedAcksResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryUnreceivedPacketsRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.port_id.is_empty() {
+            len += 1;
+        }
+        if !self.channel_id.is_empty() {
+            len += 1;
+        }
+        if !self.packet_commitment_sequences.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.core.channel.v1.QueryUnreceivedPacketsRequest", len)?;
+        if !self.port_id.is_empty() {
+            struct_ser.serialize_field("portId", &self.port_id)?;
+        }
+        if !self.channel_id.is_empty() {
+            struct_ser.serialize_field("channelId", &self.channel_id)?;
+        }
+        if !self.packet_commitment_sequences.is_empty() {
+            struct_ser.serialize_field(
+                "packetCommitmentSequences",
+                &self
+                    .packet_commitment_sequences
+                    .iter()
+                    .map(ToString::to_string)
+                    .collect::<Vec<_>>(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryUnreceivedPacketsRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "port_id",
+            "portId",
+            "channel_id",
+            "channelId",
+            "packet_commitment_sequences",
+            "packetCommitmentSequences",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PortId,
+            ChannelId,
+            PacketCommitmentSequences,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "portId" | "port_id" => Ok(GeneratedField::PortId),
+                            "channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
+                            "packetCommitmentSequences" | "packet_commitment_sequences" => {
+                                Ok(GeneratedField::PacketCommitmentSequences)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryUnreceivedPacketsRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryUnreceivedPacketsRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryUnreceivedPacketsRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut port_id__ = None;
+                let mut channel_id__ = None;
+                let mut packet_commitment_sequences__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PortId => {
+                            if port_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("portId"));
+                            }
+                            port_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ChannelId => {
+                            if channel_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelId"));
+                            }
+                            channel_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::PacketCommitmentSequences => {
+                            if packet_commitment_sequences__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "packetCommitmentSequences",
+                                ));
+                            }
+                            packet_commitment_sequences__ = Some(
+                                map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
+                                    .into_iter()
+                                    .map(|x| x.0)
+                                    .collect(),
+                            );
+                        }
+                    }
+                }
+                Ok(QueryUnreceivedPacketsRequest {
+                    port_id: port_id__.unwrap_or_default(),
+                    channel_id: channel_id__.unwrap_or_default(),
+                    packet_commitment_sequences: packet_commitment_sequences__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryUnreceivedPacketsRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryUnreceivedPacketsResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.sequences.is_empty() {
+            len += 1;
+        }
+        if self.height.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.core.channel.v1.QueryUnreceivedPacketsResponse", len)?;
+        if !self.sequences.is_empty() {
+            struct_ser.serialize_field(
+                "sequences",
+                &self
+                    .sequences
+                    .iter()
+                    .map(ToString::to_string)
+                    .collect::<Vec<_>>(),
+            )?;
+        }
+        if let Some(v) = self.height.as_ref() {
+            struct_ser.serialize_field("height", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryUnreceivedPacketsResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["sequences", "height"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Sequences,
+            Height,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "sequences" => Ok(GeneratedField::Sequences),
+                            "height" => Ok(GeneratedField::Height),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryUnreceivedPacketsResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.channel.v1.QueryUnreceivedPacketsResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryUnreceivedPacketsResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut sequences__ = None;
+                let mut height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Sequences => {
+                            if sequences__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sequences"));
+                            }
+                            sequences__ = Some(
+                                map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
+                                    .into_iter()
+                                    .map(|x| x.0)
+                                    .collect(),
+                            );
+                        }
+                        GeneratedField::Height => {
+                            if height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("height"));
+                            }
+                            height__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryUnreceivedPacketsResponse {
+                    sequences: sequences__.unwrap_or_default(),
+                    height: height__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.channel.v1.QueryUnreceivedPacketsResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for ResponseResultType {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::Unspecified => "RESPONSE_RESULT_TYPE_UNSPECIFIED",
+            Self::Noop => "RESPONSE_RESULT_TYPE_NOOP",
+            Self::Success => "RESPONSE_RESULT_TYPE_SUCCESS",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ResponseResultType {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "RESPONSE_RESULT_TYPE_UNSPECIFIED",
+            "RESPONSE_RESULT_TYPE_NOOP",
+            "RESPONSE_RESULT_TYPE_SUCCESS",
+        ];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ResponseResultType;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                i32::try_from(v)
+                    .ok()
+                    .and_then(|x| x.try_into().ok())
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                i32::try_from(v)
+                    .ok()
+                    .and_then(|x| x.try_into().ok())
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "RESPONSE_RESULT_TYPE_UNSPECIFIED" => Ok(ResponseResultType::Unspecified),
+                    "RESPONSE_RESULT_TYPE_NOOP" => Ok(ResponseResultType::Noop),
+                    "RESPONSE_RESULT_TYPE_SUCCESS" => Ok(ResponseResultType::Success),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for State {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::UninitializedUnspecified => "STATE_UNINITIALIZED_UNSPECIFIED",
+            Self::Init => "STATE_INIT",
+            Self::Tryopen => "STATE_TRYOPEN",
+            Self::Open => "STATE_OPEN",
+            Self::Closed => "STATE_CLOSED",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for State {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "STATE_UNINITIALIZED_UNSPECIFIED",
+            "STATE_INIT",
+            "STATE_TRYOPEN",
+            "STATE_OPEN",
+            "STATE_CLOSED",
+        ];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = State;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                i32::try_from(v)
+                    .ok()
+                    .and_then(|x| x.try_into().ok())
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                i32::try_from(v)
+                    .ok()
+                    .and_then(|x| x.try_into().ok())
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "STATE_UNINITIALIZED_UNSPECIFIED" => Ok(State::UninitializedUnspecified),
+                    "STATE_INIT" => Ok(State::Init),
+                    "STATE_TRYOPEN" => Ok(State::Tryopen),
+                    "STATE_OPEN" => Ok(State::Open),
+                    "STATE_CLOSED" => Ok(State::Closed),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.channel.v1.tonic.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.channel.v1.tonic.rs
new file mode 100644
index 00000000..7b8374e6
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.channel.v1.tonic.rs
@@ -0,0 +1,1937 @@
+// @generated
+/// Generated client implementations.
+#[cfg(feature = "grpc")]
+pub mod query_client {
+    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
+    use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
+    #[derive(Debug, Clone)]
+    pub struct QueryClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    #[cfg(feature = "grpc-transport")]
+    impl QueryClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> QueryClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> QueryClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
+                Into<StdError> + Send + Sync,
+        {
+            QueryClient::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
+        }
+        pub async fn channel(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryChannelRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryChannelResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Query/Channel");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("ibc.core.channel.v1.Query", "Channel"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn channels(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryChannelsRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryChannelsResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Query/Channels");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("ibc.core.channel.v1.Query", "Channels"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn connection_channels(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryConnectionChannelsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryConnectionChannelsResponse>,
+            tonic::Status,
+        > {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/ibc.core.channel.v1.Query/ConnectionChannels",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.channel.v1.Query",
+                "ConnectionChannels",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn channel_client_state(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryChannelClientStateRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryChannelClientStateResponse>,
+            tonic::Status,
+        > {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/ibc.core.channel.v1.Query/ChannelClientState",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.channel.v1.Query",
+                "ChannelClientState",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn channel_consensus_state(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryChannelConsensusStateRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryChannelConsensusStateResponse>,
+            tonic::Status,
+        > {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/ibc.core.channel.v1.Query/ChannelConsensusState",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.channel.v1.Query",
+                "ChannelConsensusState",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn packet_commitment(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryPacketCommitmentRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryPacketCommitmentResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path =
+                http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Query/PacketCommitment");
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.channel.v1.Query",
+                "PacketCommitment",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn packet_commitments(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryPacketCommitmentsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryPacketCommitmentsResponse>,
+            tonic::Status,
+        > {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/ibc.core.channel.v1.Query/PacketCommitments",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.channel.v1.Query",
+                "PacketCommitments",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn packet_receipt(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryPacketReceiptRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryPacketReceiptResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path =
+                http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Query/PacketReceipt");
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.channel.v1.Query",
+                "PacketReceipt",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn packet_acknowledgement(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryPacketAcknowledgementRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryPacketAcknowledgementResponse>,
+            tonic::Status,
+        > {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/ibc.core.channel.v1.Query/PacketAcknowledgement",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.channel.v1.Query",
+                "PacketAcknowledgement",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn packet_acknowledgements(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryPacketAcknowledgementsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryPacketAcknowledgementsResponse>,
+            tonic::Status,
+        > {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/ibc.core.channel.v1.Query/PacketAcknowledgements",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.channel.v1.Query",
+                "PacketAcknowledgements",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn unreceived_packets(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryUnreceivedPacketsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryUnreceivedPacketsResponse>,
+            tonic::Status,
+        > {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/ibc.core.channel.v1.Query/UnreceivedPackets",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.channel.v1.Query",
+                "UnreceivedPackets",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn unreceived_acks(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryUnreceivedAcksRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryUnreceivedAcksResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path =
+                http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Query/UnreceivedAcks");
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.channel.v1.Query",
+                "UnreceivedAcks",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn next_sequence_receive(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryNextSequenceReceiveRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryNextSequenceReceiveResponse>,
+            tonic::Status,
+        > {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/ibc.core.channel.v1.Query/NextSequenceReceive",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.channel.v1.Query",
+                "NextSequenceReceive",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+#[cfg(feature = "grpc")]
+pub mod query_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 QueryServer.
+    #[async_trait]
+    pub trait Query: Send + Sync + 'static {
+        async fn channel(
+            &self,
+            request: tonic::Request<super::QueryChannelRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryChannelResponse>, tonic::Status>;
+        async fn channels(
+            &self,
+            request: tonic::Request<super::QueryChannelsRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryChannelsResponse>, tonic::Status>;
+        async fn connection_channels(
+            &self,
+            request: tonic::Request<super::QueryConnectionChannelsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryConnectionChannelsResponse>,
+            tonic::Status,
+        >;
+        async fn channel_client_state(
+            &self,
+            request: tonic::Request<super::QueryChannelClientStateRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryChannelClientStateResponse>,
+            tonic::Status,
+        >;
+        async fn channel_consensus_state(
+            &self,
+            request: tonic::Request<super::QueryChannelConsensusStateRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryChannelConsensusStateResponse>,
+            tonic::Status,
+        >;
+        async fn packet_commitment(
+            &self,
+            request: tonic::Request<super::QueryPacketCommitmentRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryPacketCommitmentResponse>, tonic::Status>;
+        async fn packet_commitments(
+            &self,
+            request: tonic::Request<super::QueryPacketCommitmentsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryPacketCommitmentsResponse>,
+            tonic::Status,
+        >;
+        async fn packet_receipt(
+            &self,
+            request: tonic::Request<super::QueryPacketReceiptRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryPacketReceiptResponse>, tonic::Status>;
+        async fn packet_acknowledgement(
+            &self,
+            request: tonic::Request<super::QueryPacketAcknowledgementRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryPacketAcknowledgementResponse>,
+            tonic::Status,
+        >;
+        async fn packet_acknowledgements(
+            &self,
+            request: tonic::Request<super::QueryPacketAcknowledgementsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryPacketAcknowledgementsResponse>,
+            tonic::Status,
+        >;
+        async fn unreceived_packets(
+            &self,
+            request: tonic::Request<super::QueryUnreceivedPacketsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryUnreceivedPacketsResponse>,
+            tonic::Status,
+        >;
+        async fn unreceived_acks(
+            &self,
+            request: tonic::Request<super::QueryUnreceivedAcksRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryUnreceivedAcksResponse>, tonic::Status>;
+        async fn next_sequence_receive(
+            &self,
+            request: tonic::Request<super::QueryNextSequenceReceiveRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryNextSequenceReceiveResponse>,
+            tonic::Status,
+        >;
+    }
+    #[derive(Debug)]
+    pub struct QueryServer<T: Query> {
+        inner: _Inner<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    struct _Inner<T>(Arc<T>);
+    impl<T: Query> QueryServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            let inner = _Inner(inner);
+            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<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
+        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<T, B> tonic::codegen::Service<http::Request<B>> for QueryServer<T>
+    where
+        T: Query,
+        B: Body + Send + 'static,
+        B::Error: Into<StdError> + Send + 'static,
+    {
+        type Response = http::Response<tonic::body::BoxBody>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            let inner = self.inner.clone();
+            match req.uri().path() {
+                "/ibc.core.channel.v1.Query/Channel" => {
+                    #[allow(non_camel_case_types)]
+                    struct ChannelSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryChannelRequest> for ChannelSvc<T> {
+                        type Response = super::QueryChannelResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryChannelRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).channel(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 = ChannelSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.channel.v1.Query/Channels" => {
+                    #[allow(non_camel_case_types)]
+                    struct ChannelsSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryChannelsRequest> for ChannelsSvc<T> {
+                        type Response = super::QueryChannelsResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryChannelsRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).channels(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 = ChannelsSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.channel.v1.Query/ConnectionChannels" => {
+                    #[allow(non_camel_case_types)]
+                    struct ConnectionChannelsSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query>
+                        tonic::server::UnaryService<super::QueryConnectionChannelsRequest>
+                        for ConnectionChannelsSvc<T>
+                    {
+                        type Response = super::QueryConnectionChannelsResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryConnectionChannelsRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).connection_channels(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 = ConnectionChannelsSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.channel.v1.Query/ChannelClientState" => {
+                    #[allow(non_camel_case_types)]
+                    struct ChannelClientStateSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query>
+                        tonic::server::UnaryService<super::QueryChannelClientStateRequest>
+                        for ChannelClientStateSvc<T>
+                    {
+                        type Response = super::QueryChannelClientStateResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryChannelClientStateRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).channel_client_state(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 = ChannelClientStateSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.channel.v1.Query/ChannelConsensusState" => {
+                    #[allow(non_camel_case_types)]
+                    struct ChannelConsensusStateSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query>
+                        tonic::server::UnaryService<super::QueryChannelConsensusStateRequest>
+                        for ChannelConsensusStateSvc<T>
+                    {
+                        type Response = super::QueryChannelConsensusStateResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryChannelConsensusStateRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut =
+                                async move { (*inner).channel_consensus_state(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 = ChannelConsensusStateSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.channel.v1.Query/PacketCommitment" => {
+                    #[allow(non_camel_case_types)]
+                    struct PacketCommitmentSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryPacketCommitmentRequest>
+                        for PacketCommitmentSvc<T>
+                    {
+                        type Response = super::QueryPacketCommitmentResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryPacketCommitmentRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).packet_commitment(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 = PacketCommitmentSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.channel.v1.Query/PacketCommitments" => {
+                    #[allow(non_camel_case_types)]
+                    struct PacketCommitmentsSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryPacketCommitmentsRequest>
+                        for PacketCommitmentsSvc<T>
+                    {
+                        type Response = super::QueryPacketCommitmentsResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryPacketCommitmentsRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).packet_commitments(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 = PacketCommitmentsSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.channel.v1.Query/PacketReceipt" => {
+                    #[allow(non_camel_case_types)]
+                    struct PacketReceiptSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryPacketReceiptRequest>
+                        for PacketReceiptSvc<T>
+                    {
+                        type Response = super::QueryPacketReceiptResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryPacketReceiptRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).packet_receipt(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 = PacketReceiptSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.channel.v1.Query/PacketAcknowledgement" => {
+                    #[allow(non_camel_case_types)]
+                    struct PacketAcknowledgementSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query>
+                        tonic::server::UnaryService<super::QueryPacketAcknowledgementRequest>
+                        for PacketAcknowledgementSvc<T>
+                    {
+                        type Response = super::QueryPacketAcknowledgementResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryPacketAcknowledgementRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).packet_acknowledgement(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 = PacketAcknowledgementSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.channel.v1.Query/PacketAcknowledgements" => {
+                    #[allow(non_camel_case_types)]
+                    struct PacketAcknowledgementsSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query>
+                        tonic::server::UnaryService<super::QueryPacketAcknowledgementsRequest>
+                        for PacketAcknowledgementsSvc<T>
+                    {
+                        type Response = super::QueryPacketAcknowledgementsResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryPacketAcknowledgementsRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut =
+                                async move { (*inner).packet_acknowledgements(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 = PacketAcknowledgementsSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.channel.v1.Query/UnreceivedPackets" => {
+                    #[allow(non_camel_case_types)]
+                    struct UnreceivedPacketsSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryUnreceivedPacketsRequest>
+                        for UnreceivedPacketsSvc<T>
+                    {
+                        type Response = super::QueryUnreceivedPacketsResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryUnreceivedPacketsRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).unreceived_packets(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 = UnreceivedPacketsSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.channel.v1.Query/UnreceivedAcks" => {
+                    #[allow(non_camel_case_types)]
+                    struct UnreceivedAcksSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryUnreceivedAcksRequest>
+                        for UnreceivedAcksSvc<T>
+                    {
+                        type Response = super::QueryUnreceivedAcksResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryUnreceivedAcksRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).unreceived_acks(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 = UnreceivedAcksSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.channel.v1.Query/NextSequenceReceive" => {
+                    #[allow(non_camel_case_types)]
+                    struct NextSequenceReceiveSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query>
+                        tonic::server::UnaryService<super::QueryNextSequenceReceiveRequest>
+                        for NextSequenceReceiveSvc<T>
+                    {
+                        type Response = super::QueryNextSequenceReceiveResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryNextSequenceReceiveRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).next_sequence_receive(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 = NextSequenceReceiveSvc(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", "12")
+                        .header("content-type", "application/grpc")
+                        .body(empty_body())
+                        .unwrap())
+                }),
+            }
+        }
+    }
+    impl<T: Query> Clone for QueryServer<T> {
+        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<T: Query> Clone for _Inner<T> {
+        fn clone(&self) -> Self {
+            Self(Arc::clone(&self.0))
+        }
+    }
+    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "{:?}", self.0)
+        }
+    }
+    impl<T: Query> tonic::server::NamedService for QueryServer<T> {
+        const NAME: &'static str = "ibc.core.channel.v1.Query";
+    }
+}
+/// Generated client implementations.
+#[cfg(feature = "grpc")]
+pub mod msg_client {
+    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
+    use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
+    #[derive(Debug, Clone)]
+    pub struct MsgClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    #[cfg(feature = "grpc-transport")]
+    impl MsgClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> MsgClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(inner: T, interceptor: F) -> MsgClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
+                Into<StdError> + Send + Sync,
+        {
+            MsgClient::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
+        }
+        pub async fn channel_open_init(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgChannelOpenInit>,
+        ) -> std::result::Result<tonic::Response<super::MsgChannelOpenInitResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path =
+                http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Msg/ChannelOpenInit");
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.channel.v1.Msg",
+                "ChannelOpenInit",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn channel_open_try(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgChannelOpenTry>,
+        ) -> std::result::Result<tonic::Response<super::MsgChannelOpenTryResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path =
+                http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Msg/ChannelOpenTry");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("ibc.core.channel.v1.Msg", "ChannelOpenTry"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn channel_open_ack(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgChannelOpenAck>,
+        ) -> std::result::Result<tonic::Response<super::MsgChannelOpenAckResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path =
+                http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Msg/ChannelOpenAck");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("ibc.core.channel.v1.Msg", "ChannelOpenAck"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn channel_open_confirm(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgChannelOpenConfirm>,
+        ) -> std::result::Result<tonic::Response<super::MsgChannelOpenConfirmResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path =
+                http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Msg/ChannelOpenConfirm");
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.channel.v1.Msg",
+                "ChannelOpenConfirm",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn channel_close_init(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgChannelCloseInit>,
+        ) -> std::result::Result<tonic::Response<super::MsgChannelCloseInitResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path =
+                http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Msg/ChannelCloseInit");
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.channel.v1.Msg",
+                "ChannelCloseInit",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn channel_close_confirm(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgChannelCloseConfirm>,
+        ) -> std::result::Result<
+            tonic::Response<super::MsgChannelCloseConfirmResponse>,
+            tonic::Status,
+        > {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/ibc.core.channel.v1.Msg/ChannelCloseConfirm",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.channel.v1.Msg",
+                "ChannelCloseConfirm",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn recv_packet(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgRecvPacket>,
+        ) -> std::result::Result<tonic::Response<super::MsgRecvPacketResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Msg/RecvPacket");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("ibc.core.channel.v1.Msg", "RecvPacket"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn timeout(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgTimeout>,
+        ) -> std::result::Result<tonic::Response<super::MsgTimeoutResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Msg/Timeout");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("ibc.core.channel.v1.Msg", "Timeout"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn timeout_on_close(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgTimeoutOnClose>,
+        ) -> std::result::Result<tonic::Response<super::MsgTimeoutOnCloseResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path =
+                http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Msg/TimeoutOnClose");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("ibc.core.channel.v1.Msg", "TimeoutOnClose"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn acknowledgement(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgAcknowledgement>,
+        ) -> std::result::Result<tonic::Response<super::MsgAcknowledgementResponse>, tonic::Status>
+        {
+            self.inner.ready().await.map_err(|e| {
+                tonic::Status::new(
+                    tonic::Code::Unknown,
+                    format!("Service was not ready: {}", e.into()),
+                )
+            })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path =
+                http::uri::PathAndQuery::from_static("/ibc.core.channel.v1.Msg/Acknowledgement");
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.channel.v1.Msg",
+                "Acknowledgement",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+#[cfg(feature = "grpc")]
+pub mod msg_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 MsgServer.
+    #[async_trait]
+    pub trait Msg: Send + Sync + 'static {
+        async fn channel_open_init(
+            &self,
+            request: tonic::Request<super::MsgChannelOpenInit>,
+        ) -> std::result::Result<tonic::Response<super::MsgChannelOpenInitResponse>, tonic::Status>;
+        async fn channel_open_try(
+            &self,
+            request: tonic::Request<super::MsgChannelOpenTry>,
+        ) -> std::result::Result<tonic::Response<super::MsgChannelOpenTryResponse>, tonic::Status>;
+        async fn channel_open_ack(
+            &self,
+            request: tonic::Request<super::MsgChannelOpenAck>,
+        ) -> std::result::Result<tonic::Response<super::MsgChannelOpenAckResponse>, tonic::Status>;
+        async fn channel_open_confirm(
+            &self,
+            request: tonic::Request<super::MsgChannelOpenConfirm>,
+        ) -> std::result::Result<tonic::Response<super::MsgChannelOpenConfirmResponse>, tonic::Status>;
+        async fn channel_close_init(
+            &self,
+            request: tonic::Request<super::MsgChannelCloseInit>,
+        ) -> std::result::Result<tonic::Response<super::MsgChannelCloseInitResponse>, tonic::Status>;
+        async fn channel_close_confirm(
+            &self,
+            request: tonic::Request<super::MsgChannelCloseConfirm>,
+        ) -> std::result::Result<
+            tonic::Response<super::MsgChannelCloseConfirmResponse>,
+            tonic::Status,
+        >;
+        async fn recv_packet(
+            &self,
+            request: tonic::Request<super::MsgRecvPacket>,
+        ) -> std::result::Result<tonic::Response<super::MsgRecvPacketResponse>, tonic::Status>;
+        async fn timeout(
+            &self,
+            request: tonic::Request<super::MsgTimeout>,
+        ) -> std::result::Result<tonic::Response<super::MsgTimeoutResponse>, tonic::Status>;
+        async fn timeout_on_close(
+            &self,
+            request: tonic::Request<super::MsgTimeoutOnClose>,
+        ) -> std::result::Result<tonic::Response<super::MsgTimeoutOnCloseResponse>, tonic::Status>;
+        async fn acknowledgement(
+            &self,
+            request: tonic::Request<super::MsgAcknowledgement>,
+        ) -> std::result::Result<tonic::Response<super::MsgAcknowledgementResponse>, tonic::Status>;
+    }
+    #[derive(Debug)]
+    pub struct MsgServer<T: Msg> {
+        inner: _Inner<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    struct _Inner<T>(Arc<T>);
+    impl<T: Msg> MsgServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            let inner = _Inner(inner);
+            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<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
+        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<T, B> tonic::codegen::Service<http::Request<B>> for MsgServer<T>
+    where
+        T: Msg,
+        B: Body + Send + 'static,
+        B::Error: Into<StdError> + Send + 'static,
+    {
+        type Response = http::Response<tonic::body::BoxBody>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            let inner = self.inner.clone();
+            match req.uri().path() {
+                "/ibc.core.channel.v1.Msg/ChannelOpenInit" => {
+                    #[allow(non_camel_case_types)]
+                    struct ChannelOpenInitSvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgChannelOpenInit> for ChannelOpenInitSvc<T> {
+                        type Response = super::MsgChannelOpenInitResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgChannelOpenInit>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).channel_open_init(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 = ChannelOpenInitSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.channel.v1.Msg/ChannelOpenTry" => {
+                    #[allow(non_camel_case_types)]
+                    struct ChannelOpenTrySvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgChannelOpenTry> for ChannelOpenTrySvc<T> {
+                        type Response = super::MsgChannelOpenTryResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgChannelOpenTry>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).channel_open_try(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 = ChannelOpenTrySvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.channel.v1.Msg/ChannelOpenAck" => {
+                    #[allow(non_camel_case_types)]
+                    struct ChannelOpenAckSvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgChannelOpenAck> for ChannelOpenAckSvc<T> {
+                        type Response = super::MsgChannelOpenAckResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgChannelOpenAck>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).channel_open_ack(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 = ChannelOpenAckSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.channel.v1.Msg/ChannelOpenConfirm" => {
+                    #[allow(non_camel_case_types)]
+                    struct ChannelOpenConfirmSvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgChannelOpenConfirm>
+                        for ChannelOpenConfirmSvc<T>
+                    {
+                        type Response = super::MsgChannelOpenConfirmResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgChannelOpenConfirm>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).channel_open_confirm(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 = ChannelOpenConfirmSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.channel.v1.Msg/ChannelCloseInit" => {
+                    #[allow(non_camel_case_types)]
+                    struct ChannelCloseInitSvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgChannelCloseInit> for ChannelCloseInitSvc<T> {
+                        type Response = super::MsgChannelCloseInitResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgChannelCloseInit>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).channel_close_init(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 = ChannelCloseInitSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.channel.v1.Msg/ChannelCloseConfirm" => {
+                    #[allow(non_camel_case_types)]
+                    struct ChannelCloseConfirmSvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgChannelCloseConfirm>
+                        for ChannelCloseConfirmSvc<T>
+                    {
+                        type Response = super::MsgChannelCloseConfirmResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgChannelCloseConfirm>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).channel_close_confirm(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 = ChannelCloseConfirmSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.channel.v1.Msg/RecvPacket" => {
+                    #[allow(non_camel_case_types)]
+                    struct RecvPacketSvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgRecvPacket> for RecvPacketSvc<T> {
+                        type Response = super::MsgRecvPacketResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgRecvPacket>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).recv_packet(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 = RecvPacketSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.channel.v1.Msg/Timeout" => {
+                    #[allow(non_camel_case_types)]
+                    struct TimeoutSvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgTimeout> for TimeoutSvc<T> {
+                        type Response = super::MsgTimeoutResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgTimeout>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).timeout(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 = TimeoutSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.channel.v1.Msg/TimeoutOnClose" => {
+                    #[allow(non_camel_case_types)]
+                    struct TimeoutOnCloseSvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgTimeoutOnClose> for TimeoutOnCloseSvc<T> {
+                        type Response = super::MsgTimeoutOnCloseResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgTimeoutOnClose>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).timeout_on_close(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 = TimeoutOnCloseSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.channel.v1.Msg/Acknowledgement" => {
+                    #[allow(non_camel_case_types)]
+                    struct AcknowledgementSvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgAcknowledgement> for AcknowledgementSvc<T> {
+                        type Response = super::MsgAcknowledgementResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgAcknowledgement>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).acknowledgement(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 = AcknowledgementSvc(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", "12")
+                        .header("content-type", "application/grpc")
+                        .body(empty_body())
+                        .unwrap())
+                }),
+            }
+        }
+    }
+    impl<T: Msg> Clone for MsgServer<T> {
+        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<T: Msg> Clone for _Inner<T> {
+        fn clone(&self) -> Self {
+            Self(Arc::clone(&self.0))
+        }
+    }
+    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "{:?}", self.0)
+        }
+    }
+    impl<T: Msg> tonic::server::NamedService for MsgServer<T> {
+        const NAME: &'static str = "ibc.core.channel.v1.Msg";
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.client.v1.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.client.v1.rs
index 9a48c10c..626875a9 100644
--- a/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.client.v1.rs
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.client.v1.rs
@@ -1,4 +1,4 @@
-// This file is @generated by prost-build.
+// @generated
 /// IdentifiedClientState defines a client state with an additional client
 /// identifier field.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -11,16 +11,6 @@ pub struct IdentifiedClientState {
     #[prost(message, optional, tag = "2")]
     pub client_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
 }
-impl ::prost::Name for IdentifiedClientState {
-    const NAME: &'static str = "IdentifiedClientState";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.IdentifiedClientState".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.IdentifiedClientState".into()
-    }
-}
 /// ConsensusStateWithHeight defines a consensus state with an additional height
 /// field.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -33,16 +23,6 @@ pub struct ConsensusStateWithHeight {
     #[prost(message, optional, tag = "2")]
     pub consensus_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
 }
-impl ::prost::Name for ConsensusStateWithHeight {
-    const NAME: &'static str = "ConsensusStateWithHeight";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.ConsensusStateWithHeight".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.ConsensusStateWithHeight".into()
-    }
-}
 /// ClientConsensusStates defines all the stored consensus states for a given
 /// client.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -55,16 +35,6 @@ pub struct ClientConsensusStates {
     #[prost(message, repeated, tag = "2")]
     pub consensus_states: ::prost::alloc::vec::Vec<ConsensusStateWithHeight>,
 }
-impl ::prost::Name for ClientConsensusStates {
-    const NAME: &'static str = "ClientConsensusStates";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.ClientConsensusStates".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.ClientConsensusStates".into()
-    }
-}
 /// ClientUpdateProposal is a 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
@@ -86,16 +56,6 @@ pub struct ClientUpdateProposal {
     #[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.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -116,16 +76,6 @@ pub struct UpgradeProposal {
     #[prost(message, optional, tag = "4")]
     pub upgraded_client_state: ::core::option::Option<::tendermint_proto::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()
-    }
-}
 /// Height is a monotonically increasing data type
 /// that can be compared against another Height for the purposes of updating and
 /// freezing clients
@@ -137,7 +87,7 @@ impl ::prost::Name for UpgradeProposal {
 /// height continues to be monitonically increasing even as the RevisionHeight
 /// gets reset
 #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Height {
     /// the revision that the client is currently on
     #[prost(uint64, tag = "1")]
@@ -146,16 +96,6 @@ pub struct Height {
     #[prost(uint64, tag = "2")]
     pub revision_height: u64,
 }
-impl ::prost::Name for Height {
-    const NAME: &'static str = "Height";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.Height".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.Height".into()
-    }
-}
 /// Params defines the set of IBC light client parameters.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -164,348 +104,49 @@ pub struct Params {
     #[prost(string, repeated, tag = "1")]
     pub allowed_clients: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
 }
-impl ::prost::Name for Params {
-    const NAME: &'static str = "Params";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.Params".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.Params".into()
-    }
-}
-/// MsgCreateClient defines a message to create an IBC client
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MsgCreateClient {
-    /// light client state
-    #[prost(message, optional, tag = "1")]
-    pub client_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
-    /// consensus state associated with the client that corresponds to a given
-    /// height.
-    #[prost(message, optional, tag = "2")]
-    pub consensus_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
-    /// signer address
-    #[prost(string, tag = "3")]
-    pub signer: ::prost::alloc::string::String,
-}
-impl ::prost::Name for MsgCreateClient {
-    const NAME: &'static str = "MsgCreateClient";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.MsgCreateClient".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.MsgCreateClient".into()
-    }
-}
-/// MsgCreateClientResponse defines the Msg/CreateClient response type.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct MsgCreateClientResponse {}
-impl ::prost::Name for MsgCreateClientResponse {
-    const NAME: &'static str = "MsgCreateClientResponse";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.MsgCreateClientResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.MsgCreateClientResponse".into()
-    }
-}
-/// MsgUpdateClient defines an sdk.Msg to update a IBC client state using
-/// the given header.
+/// GenesisState defines the ibc client submodule's genesis state.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MsgUpdateClient {
-    /// client unique identifier
-    #[prost(string, tag = "1")]
-    pub client_id: ::prost::alloc::string::String,
-    /// header to update the light client
-    #[prost(message, optional, tag = "2")]
-    pub header: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
-    /// signer address
-    #[prost(string, tag = "3")]
-    pub signer: ::prost::alloc::string::String,
-}
-impl ::prost::Name for MsgUpdateClient {
-    const NAME: &'static str = "MsgUpdateClient";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.MsgUpdateClient".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.MsgUpdateClient".into()
-    }
-}
-/// MsgUpdateClientResponse defines the Msg/UpdateClient response type.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct MsgUpdateClientResponse {}
-impl ::prost::Name for MsgUpdateClientResponse {
-    const NAME: &'static str = "MsgUpdateClientResponse";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.MsgUpdateClientResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.MsgUpdateClientResponse".into()
-    }
+pub struct GenesisState {
+    /// client states with their corresponding identifiers
+    #[prost(message, repeated, tag = "1")]
+    pub clients: ::prost::alloc::vec::Vec<IdentifiedClientState>,
+    /// consensus states from each client
+    #[prost(message, repeated, tag = "2")]
+    pub clients_consensus: ::prost::alloc::vec::Vec<ClientConsensusStates>,
+    /// metadata from each client
+    #[prost(message, repeated, tag = "3")]
+    pub clients_metadata: ::prost::alloc::vec::Vec<IdentifiedGenesisMetadata>,
+    #[prost(message, optional, tag = "4")]
+    pub params: ::core::option::Option<Params>,
+    /// create localhost on initialization
+    #[prost(bool, tag = "5")]
+    pub create_localhost: bool,
+    /// the sequence for the next generated client identifier
+    #[prost(uint64, tag = "6")]
+    pub next_client_sequence: u64,
 }
-/// MsgUpgradeClient defines an sdk.Msg to upgrade an IBC client to a new client
-/// state
+/// GenesisMetadata defines the genesis type for metadata that clients may return
+/// with ExportMetadata
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MsgUpgradeClient {
-    /// client unique identifier
-    #[prost(string, tag = "1")]
-    pub client_id: ::prost::alloc::string::String,
-    /// upgraded client state
-    #[prost(message, optional, tag = "2")]
-    pub client_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
-    /// upgraded consensus state, only contains enough information to serve as a
-    /// basis of trust in update logic
-    #[prost(message, optional, tag = "3")]
-    pub consensus_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
-    /// proof that old chain committed to new client
-    #[prost(bytes = "vec", tag = "4")]
-    pub proof_upgrade_client: ::prost::alloc::vec::Vec<u8>,
-    /// proof that old chain committed to new consensus state
-    #[prost(bytes = "vec", tag = "5")]
-    pub proof_upgrade_consensus_state: ::prost::alloc::vec::Vec<u8>,
-    /// signer address
-    #[prost(string, tag = "6")]
-    pub signer: ::prost::alloc::string::String,
-}
-impl ::prost::Name for MsgUpgradeClient {
-    const NAME: &'static str = "MsgUpgradeClient";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.MsgUpgradeClient".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.MsgUpgradeClient".into()
-    }
-}
-/// MsgUpgradeClientResponse defines the Msg/UpgradeClient response type.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct MsgUpgradeClientResponse {}
-impl ::prost::Name for MsgUpgradeClientResponse {
-    const NAME: &'static str = "MsgUpgradeClientResponse";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.MsgUpgradeClientResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.MsgUpgradeClientResponse".into()
-    }
+pub struct GenesisMetadata {
+    /// store key of metadata without clientID-prefix
+    #[prost(bytes = "vec", tag = "1")]
+    pub key: ::prost::alloc::vec::Vec<u8>,
+    /// metadata value
+    #[prost(bytes = "vec", tag = "2")]
+    pub value: ::prost::alloc::vec::Vec<u8>,
 }
-/// MsgSubmitMisbehaviour defines an sdk.Msg type that submits Evidence for
-/// light client misbehaviour.
+/// IdentifiedGenesisMetadata has the client metadata with the corresponding
+/// client id.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MsgSubmitMisbehaviour {
-    /// client unique identifier
+pub struct IdentifiedGenesisMetadata {
     #[prost(string, tag = "1")]
     pub client_id: ::prost::alloc::string::String,
-    /// misbehaviour used for freezing the light client
-    #[prost(message, optional, tag = "2")]
-    pub misbehaviour: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
-    /// signer address
-    #[prost(string, tag = "3")]
-    pub signer: ::prost::alloc::string::String,
-}
-impl ::prost::Name for MsgSubmitMisbehaviour {
-    const NAME: &'static str = "MsgSubmitMisbehaviour";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.MsgSubmitMisbehaviour".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.MsgSubmitMisbehaviour".into()
-    }
-}
-/// MsgSubmitMisbehaviourResponse defines the Msg/SubmitMisbehaviour response
-/// type.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct MsgSubmitMisbehaviourResponse {}
-impl ::prost::Name for MsgSubmitMisbehaviourResponse {
-    const NAME: &'static str = "MsgSubmitMisbehaviourResponse";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.MsgSubmitMisbehaviourResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.MsgSubmitMisbehaviourResponse".into()
-    }
-}
-/// Generated client implementations.
-#[cfg(feature = "grpc")]
-pub mod msg_client {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
-    use tonic::codegen::http::Uri;
-    use tonic::codegen::*;
-    /// Msg defines the ibc/client Msg service.
-    #[derive(Debug, Clone)]
-    pub struct MsgClient<T> {
-        inner: tonic::client::Grpc<T>,
-    }
-    #[cfg(feature = "grpc-transport")]
-    impl MsgClient<tonic::transport::Channel> {
-        /// Attempt to create a new client by connecting to a given endpoint.
-        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
-        where
-            D: TryInto<tonic::transport::Endpoint>,
-            D::Error: Into<StdError>,
-        {
-            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
-            Ok(Self::new(conn))
-        }
-    }
-    impl<T> MsgClient<T>
-    where
-        T: tonic::client::GrpcService<tonic::body::BoxBody>,
-        T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(inner: T, interceptor: F) -> MsgClient<InterceptedService<T, F>>
-        where
-            F: tonic::service::Interceptor,
-            T::ResponseBody: Default,
-            T: tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
-                Response = http::Response<
-                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
-                >,
-            >,
-            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
-                Into<StdError> + Send + Sync,
-        {
-            MsgClient::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
-        }
-        /// CreateClient defines a rpc handler method for MsgCreateClient.
-        pub async fn create_client(
-            &mut self,
-            request: impl tonic::IntoRequest<super::MsgCreateClient>,
-        ) -> std::result::Result<tonic::Response<super::MsgCreateClientResponse>, 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.Msg/CreateClient");
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ibc.core.client.v1.Msg", "CreateClient"));
-            self.inner.unary(req, path, codec).await
-        }
-        /// UpdateClient defines a rpc handler method for MsgUpdateClient.
-        pub async fn update_client(
-            &mut self,
-            request: impl tonic::IntoRequest<super::MsgUpdateClient>,
-        ) -> std::result::Result<tonic::Response<super::MsgUpdateClientResponse>, 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.Msg/UpdateClient");
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ibc.core.client.v1.Msg", "UpdateClient"));
-            self.inner.unary(req, path, codec).await
-        }
-        /// UpgradeClient defines a rpc handler method for MsgUpgradeClient.
-        pub async fn upgrade_client(
-            &mut self,
-            request: impl tonic::IntoRequest<super::MsgUpgradeClient>,
-        ) -> std::result::Result<tonic::Response<super::MsgUpgradeClientResponse>, 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.Msg/UpgradeClient");
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ibc.core.client.v1.Msg", "UpgradeClient"));
-            self.inner.unary(req, path, codec).await
-        }
-        /// SubmitMisbehaviour defines a rpc handler method for MsgSubmitMisbehaviour.
-        pub async fn submit_misbehaviour(
-            &mut self,
-            request: impl tonic::IntoRequest<super::MsgSubmitMisbehaviour>,
-        ) -> std::result::Result<tonic::Response<super::MsgSubmitMisbehaviourResponse>, 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.Msg/SubmitMisbehaviour");
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.client.v1.Msg",
-                "SubmitMisbehaviour",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-    }
+    #[prost(message, repeated, tag = "2")]
+    pub client_metadata: ::prost::alloc::vec::Vec<GenesisMetadata>,
 }
 /// QueryClientStateRequest is the request type for the Query/ClientState RPC
 /// method
@@ -516,16 +157,6 @@ pub struct QueryClientStateRequest {
     #[prost(string, tag = "1")]
     pub client_id: ::prost::alloc::string::String,
 }
-impl ::prost::Name for QueryClientStateRequest {
-    const NAME: &'static str = "QueryClientStateRequest";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.QueryClientStateRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.QueryClientStateRequest".into()
-    }
-}
 /// QueryClientStateResponse is the response type for the Query/ClientState RPC
 /// method. Besides the client state, it includes a proof and the height from
 /// which the proof was retrieved.
@@ -542,16 +173,6 @@ pub struct QueryClientStateResponse {
     #[prost(message, optional, tag = "3")]
     pub proof_height: ::core::option::Option<Height>,
 }
-impl ::prost::Name for QueryClientStateResponse {
-    const NAME: &'static str = "QueryClientStateResponse";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.QueryClientStateResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.QueryClientStateResponse".into()
-    }
-}
 /// QueryClientStatesRequest is the request type for the Query/ClientStates RPC
 /// method
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -563,16 +184,6 @@ pub struct QueryClientStatesRequest {
         super::super::super::super::cosmos::base::query::v1beta1::PageRequest,
     >,
 }
-impl ::prost::Name for QueryClientStatesRequest {
-    const NAME: &'static str = "QueryClientStatesRequest";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.QueryClientStatesRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.QueryClientStatesRequest".into()
-    }
-}
 /// QueryClientStatesResponse is the response type for the Query/ClientStates RPC
 /// method.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -587,16 +198,6 @@ pub struct QueryClientStatesResponse {
         super::super::super::super::cosmos::base::query::v1beta1::PageResponse,
     >,
 }
-impl ::prost::Name for QueryClientStatesResponse {
-    const NAME: &'static str = "QueryClientStatesResponse";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.QueryClientStatesResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.QueryClientStatesResponse".into()
-    }
-}
 /// QueryConsensusStateRequest is the request type for the Query/ConsensusState
 /// RPC method. Besides the consensus state, it includes a proof and the height
 /// from which the proof was retrieved.
@@ -617,16 +218,6 @@ pub struct QueryConsensusStateRequest {
     #[prost(bool, tag = "4")]
     pub latest_height: bool,
 }
-impl ::prost::Name for QueryConsensusStateRequest {
-    const NAME: &'static str = "QueryConsensusStateRequest";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.QueryConsensusStateRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.QueryConsensusStateRequest".into()
-    }
-}
 /// QueryConsensusStateResponse is the response type for the Query/ConsensusState
 /// RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -642,16 +233,6 @@ pub struct QueryConsensusStateResponse {
     #[prost(message, optional, tag = "3")]
     pub proof_height: ::core::option::Option<Height>,
 }
-impl ::prost::Name for QueryConsensusStateResponse {
-    const NAME: &'static str = "QueryConsensusStateResponse";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.QueryConsensusStateResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.QueryConsensusStateResponse".into()
-    }
-}
 /// QueryConsensusStatesRequest is the request type for the Query/ConsensusStates
 /// RPC method.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -666,16 +247,6 @@ pub struct QueryConsensusStatesRequest {
         super::super::super::super::cosmos::base::query::v1beta1::PageRequest,
     >,
 }
-impl ::prost::Name for QueryConsensusStatesRequest {
-    const NAME: &'static str = "QueryConsensusStatesRequest";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.QueryConsensusStatesRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.QueryConsensusStatesRequest".into()
-    }
-}
 /// QueryConsensusStatesResponse is the response type for the
 /// Query/ConsensusStates RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -690,16 +261,6 @@ pub struct QueryConsensusStatesResponse {
         super::super::super::super::cosmos::base::query::v1beta1::PageResponse,
     >,
 }
-impl ::prost::Name for QueryConsensusStatesResponse {
-    const NAME: &'static str = "QueryConsensusStatesResponse";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.QueryConsensusStatesResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.QueryConsensusStatesResponse".into()
-    }
-}
 /// QueryConsensusStateHeightsRequest is the request type for Query/ConsensusStateHeights
 /// RPC method.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -714,16 +275,6 @@ pub struct QueryConsensusStateHeightsRequest {
         super::super::super::super::cosmos::base::query::v1beta1::PageRequest,
     >,
 }
-impl ::prost::Name for QueryConsensusStateHeightsRequest {
-    const NAME: &'static str = "QueryConsensusStateHeightsRequest";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.QueryConsensusStateHeightsRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.QueryConsensusStateHeightsRequest".into()
-    }
-}
 /// QueryConsensusStateHeightsResponse is the response type for the
 /// Query/ConsensusStateHeights RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -738,16 +289,6 @@ pub struct QueryConsensusStateHeightsResponse {
         super::super::super::super::cosmos::base::query::v1beta1::PageResponse,
     >,
 }
-impl ::prost::Name for QueryConsensusStateHeightsResponse {
-    const NAME: &'static str = "QueryConsensusStateHeightsResponse";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.QueryConsensusStateHeightsResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.QueryConsensusStateHeightsResponse".into()
-    }
-}
 /// QueryClientStatusRequest is the request type for the Query/ClientStatus RPC
 /// method
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -757,16 +298,6 @@ pub struct QueryClientStatusRequest {
     #[prost(string, tag = "1")]
     pub client_id: ::prost::alloc::string::String,
 }
-impl ::prost::Name for QueryClientStatusRequest {
-    const NAME: &'static str = "QueryClientStatusRequest";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.QueryClientStatusRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.QueryClientStatusRequest".into()
-    }
-}
 /// QueryClientStatusResponse is the response type for the Query/ClientStatus RPC
 /// method. It returns the current status of the IBC client.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -775,31 +306,11 @@ pub struct QueryClientStatusResponse {
     #[prost(string, tag = "1")]
     pub status: ::prost::alloc::string::String,
 }
-impl ::prost::Name for QueryClientStatusResponse {
-    const NAME: &'static str = "QueryClientStatusResponse";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.QueryClientStatusResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.QueryClientStatusResponse".into()
-    }
-}
 /// QueryClientParamsRequest is the request type for the Query/ClientParams RPC
 /// method.
 #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, ::prost::Message)]
 pub struct QueryClientParamsRequest {}
-impl ::prost::Name for QueryClientParamsRequest {
-    const NAME: &'static str = "QueryClientParamsRequest";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.QueryClientParamsRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.QueryClientParamsRequest".into()
-    }
-}
 /// QueryClientParamsResponse is the response type for the Query/ClientParams RPC
 /// method.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -809,31 +320,11 @@ pub struct QueryClientParamsResponse {
     #[prost(message, optional, tag = "1")]
     pub params: ::core::option::Option<Params>,
 }
-impl ::prost::Name for QueryClientParamsResponse {
-    const NAME: &'static str = "QueryClientParamsResponse";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.QueryClientParamsResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.QueryClientParamsResponse".into()
-    }
-}
 /// QueryUpgradedClientStateRequest is the request type for the
 /// Query/UpgradedClientState RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, ::prost::Message)]
 pub struct QueryUpgradedClientStateRequest {}
-impl ::prost::Name for QueryUpgradedClientStateRequest {
-    const NAME: &'static str = "QueryUpgradedClientStateRequest";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.QueryUpgradedClientStateRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.QueryUpgradedClientStateRequest".into()
-    }
-}
 /// QueryUpgradedClientStateResponse is the response type for the
 /// Query/UpgradedClientState RPC method.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -843,31 +334,11 @@ pub struct QueryUpgradedClientStateResponse {
     #[prost(message, optional, tag = "1")]
     pub upgraded_client_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
 }
-impl ::prost::Name for QueryUpgradedClientStateResponse {
-    const NAME: &'static str = "QueryUpgradedClientStateResponse";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.QueryUpgradedClientStateResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.QueryUpgradedClientStateResponse".into()
-    }
-}
 /// QueryUpgradedConsensusStateRequest is the request type for the
 /// Query/UpgradedConsensusState RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, ::prost::Message)]
 pub struct QueryUpgradedConsensusStateRequest {}
-impl ::prost::Name for QueryUpgradedConsensusStateRequest {
-    const NAME: &'static str = "QueryUpgradedConsensusStateRequest";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.QueryUpgradedConsensusStateRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.QueryUpgradedConsensusStateRequest".into()
-    }
-}
 /// QueryUpgradedConsensusStateResponse is the response type for the
 /// Query/UpgradedConsensusState RPC method.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -877,377 +348,93 @@ pub struct QueryUpgradedConsensusStateResponse {
     #[prost(message, optional, tag = "1")]
     pub upgraded_consensus_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
 }
-impl ::prost::Name for QueryUpgradedConsensusStateResponse {
-    const NAME: &'static str = "QueryUpgradedConsensusStateResponse";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.QueryUpgradedConsensusStateResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.QueryUpgradedConsensusStateResponse".into()
-    }
-}
-/// Generated client implementations.
-#[cfg(feature = "grpc")]
-pub mod query_client {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
-    use tonic::codegen::http::Uri;
-    use tonic::codegen::*;
-    /// Query provides defines the gRPC querier service
-    #[derive(Debug, Clone)]
-    pub struct QueryClient<T> {
-        inner: tonic::client::Grpc<T>,
-    }
-    #[cfg(feature = "grpc-transport")]
-    impl QueryClient<tonic::transport::Channel> {
-        /// Attempt to create a new client by connecting to a given endpoint.
-        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
-        where
-            D: TryInto<tonic::transport::Endpoint>,
-            D::Error: Into<StdError>,
-        {
-            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
-            Ok(Self::new(conn))
-        }
-    }
-    impl<T> QueryClient<T>
-    where
-        T: tonic::client::GrpcService<tonic::body::BoxBody>,
-        T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(
-            inner: T,
-            interceptor: F,
-        ) -> QueryClient<InterceptedService<T, F>>
-        where
-            F: tonic::service::Interceptor,
-            T::ResponseBody: Default,
-            T: tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
-                Response = http::Response<
-                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
-                >,
-            >,
-            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
-                Into<StdError> + Send + Sync,
-        {
-            QueryClient::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
-        }
-        /// ClientState queries an IBC light client.
-        pub async fn client_state(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryClientStateRequest>,
-        ) -> std::result::Result<tonic::Response<super::QueryClientStateResponse>, 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/ClientState");
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ibc.core.client.v1.Query", "ClientState"));
-            self.inner.unary(req, path, codec).await
-        }
-        /// ClientStates queries all the IBC light clients of a chain.
-        pub async fn client_states(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryClientStatesRequest>,
-        ) -> std::result::Result<tonic::Response<super::QueryClientStatesResponse>, 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/ClientStates");
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ibc.core.client.v1.Query", "ClientStates"));
-            self.inner.unary(req, path, codec).await
-        }
-        /// ConsensusState queries a consensus state associated with a client state at
-        /// a given height.
-        pub async fn consensus_state(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryConsensusStateRequest>,
-        ) -> std::result::Result<tonic::Response<super::QueryConsensusStateResponse>, 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/ConsensusState");
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.client.v1.Query",
-                "ConsensusState",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// ConsensusStates queries all the consensus state associated with a given
-        /// client.
-        pub async fn consensus_states(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryConsensusStatesRequest>,
-        ) -> std::result::Result<tonic::Response<super::QueryConsensusStatesResponse>, 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/ConsensusStates");
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.client.v1.Query",
-                "ConsensusStates",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// ConsensusStateHeights queries the height of every consensus states associated with a given client.
-        pub async fn consensus_state_heights(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryConsensusStateHeightsRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::QueryConsensusStateHeightsResponse>,
-            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/ConsensusStateHeights",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.client.v1.Query",
-                "ConsensusStateHeights",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// Status queries the status of an IBC client.
-        pub async fn client_status(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryClientStatusRequest>,
-        ) -> std::result::Result<tonic::Response<super::QueryClientStatusResponse>, 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/ClientStatus");
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ibc.core.client.v1.Query", "ClientStatus"));
-            self.inner.unary(req, path, codec).await
-        }
-        /// ClientParams queries all parameters of the ibc client submodule.
-        pub async fn client_params(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryClientParamsRequest>,
-        ) -> std::result::Result<tonic::Response<super::QueryClientParamsResponse>, 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/ClientParams");
-            let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ibc.core.client.v1.Query", "ClientParams"));
-            self.inner.unary(req, path, codec).await
-        }
-        /// UpgradedClientState queries an Upgraded IBC light client.
-        pub async fn upgraded_client_state(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryUpgradedClientStateRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::QueryUpgradedClientStateResponse>,
-            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/UpgradedClientState",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.client.v1.Query",
-                "UpgradedClientState",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// UpgradedConsensusState queries an Upgraded IBC consensus state.
-        pub async fn upgraded_consensus_state(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryUpgradedConsensusStateRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::QueryUpgradedConsensusStateResponse>,
-            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/UpgradedConsensusState",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.client.v1.Query",
-                "UpgradedConsensusState",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-    }
-}
-/// GenesisState defines the ibc client submodule's genesis state.
+/// MsgCreateClient defines a message to create an IBC client
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GenesisState {
-    /// client states with their corresponding identifiers
-    #[prost(message, repeated, tag = "1")]
-    pub clients: ::prost::alloc::vec::Vec<IdentifiedClientState>,
-    /// consensus states from each client
-    #[prost(message, repeated, tag = "2")]
-    pub clients_consensus: ::prost::alloc::vec::Vec<ClientConsensusStates>,
-    /// metadata from each client
-    #[prost(message, repeated, tag = "3")]
-    pub clients_metadata: ::prost::alloc::vec::Vec<IdentifiedGenesisMetadata>,
-    #[prost(message, optional, tag = "4")]
-    pub params: ::core::option::Option<Params>,
-    /// create localhost on initialization
-    #[prost(bool, tag = "5")]
-    pub create_localhost: bool,
-    /// the sequence for the next generated client identifier
-    #[prost(uint64, tag = "6")]
-    pub next_client_sequence: u64,
-}
-impl ::prost::Name for GenesisState {
-    const NAME: &'static str = "GenesisState";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.GenesisState".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.GenesisState".into()
-    }
+pub struct MsgCreateClient {
+    /// light client state
+    #[prost(message, optional, tag = "1")]
+    pub client_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
+    /// consensus state associated with the client that corresponds to a given
+    /// height.
+    #[prost(message, optional, tag = "2")]
+    pub consensus_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
+    /// signer address
+    #[prost(string, tag = "3")]
+    pub signer: ::prost::alloc::string::String,
 }
-/// GenesisMetadata defines the genesis type for metadata that clients may return
-/// with ExportMetadata
+/// MsgCreateClientResponse defines the Msg/CreateClient response type.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GenesisMetadata {
-    /// store key of metadata without clientID-prefix
-    #[prost(bytes = "vec", tag = "1")]
-    pub key: ::prost::alloc::vec::Vec<u8>,
-    /// metadata value
-    #[prost(bytes = "vec", tag = "2")]
-    pub value: ::prost::alloc::vec::Vec<u8>,
-}
-impl ::prost::Name for GenesisMetadata {
-    const NAME: &'static str = "GenesisMetadata";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.GenesisMetadata".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.GenesisMetadata".into()
-    }
+pub struct MsgCreateClientResponse {}
+/// MsgUpdateClient defines an sdk.Msg to update a IBC client state using
+/// the given header.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgUpdateClient {
+    /// client unique identifier
+    #[prost(string, tag = "1")]
+    pub client_id: ::prost::alloc::string::String,
+    /// header to update the light client
+    #[prost(message, optional, tag = "2")]
+    pub header: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
+    /// signer address
+    #[prost(string, tag = "3")]
+    pub signer: ::prost::alloc::string::String,
 }
-/// IdentifiedGenesisMetadata has the client metadata with the corresponding
-/// client id.
+/// MsgUpdateClientResponse defines the Msg/UpdateClient response type.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct IdentifiedGenesisMetadata {
+pub struct MsgUpdateClientResponse {}
+/// MsgUpgradeClient defines an sdk.Msg to upgrade an IBC client to a new client
+/// state
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgUpgradeClient {
+    /// client unique identifier
     #[prost(string, tag = "1")]
     pub client_id: ::prost::alloc::string::String,
-    #[prost(message, repeated, tag = "2")]
-    pub client_metadata: ::prost::alloc::vec::Vec<GenesisMetadata>,
+    /// upgraded client state
+    #[prost(message, optional, tag = "2")]
+    pub client_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
+    /// upgraded consensus state, only contains enough information to serve as a
+    /// basis of trust in update logic
+    #[prost(message, optional, tag = "3")]
+    pub consensus_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
+    /// proof that old chain committed to new client
+    #[prost(bytes = "vec", tag = "4")]
+    pub proof_upgrade_client: ::prost::alloc::vec::Vec<u8>,
+    /// proof that old chain committed to new consensus state
+    #[prost(bytes = "vec", tag = "5")]
+    pub proof_upgrade_consensus_state: ::prost::alloc::vec::Vec<u8>,
+    /// signer address
+    #[prost(string, tag = "6")]
+    pub signer: ::prost::alloc::string::String,
 }
-impl ::prost::Name for IdentifiedGenesisMetadata {
-    const NAME: &'static str = "IdentifiedGenesisMetadata";
-    const PACKAGE: &'static str = "ibc.core.client.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.client.v1.IdentifiedGenesisMetadata".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.client.v1.IdentifiedGenesisMetadata".into()
-    }
+/// MsgUpgradeClientResponse defines the Msg/UpgradeClient response type.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgUpgradeClientResponse {}
+/// MsgSubmitMisbehaviour defines an sdk.Msg type that submits Evidence for
+/// light client misbehaviour.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgSubmitMisbehaviour {
+    /// client unique identifier
+    #[prost(string, tag = "1")]
+    pub client_id: ::prost::alloc::string::String,
+    /// misbehaviour used for freezing the light client
+    #[prost(message, optional, tag = "2")]
+    pub misbehaviour: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
+    /// signer address
+    #[prost(string, tag = "3")]
+    pub signer: ::prost::alloc::string::String,
 }
+/// MsgSubmitMisbehaviourResponse defines the Msg/SubmitMisbehaviour response
+/// type.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgSubmitMisbehaviourResponse {}
+include!("ibc.core.client.v1.serde.rs");
+include!("ibc.core.client.v1.tonic.rs");
+// @@protoc_insertion_point(module)
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.client.v1.serde.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.client.v1.serde.rs
new file mode 100644
index 00000000..8de8633f
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.client.v1.serde.rs
@@ -0,0 +1,4380 @@
+// @generated
+#[cfg(feature = "serde")]
+impl serde::Serialize for ClientConsensusStates {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        if !self.consensus_states.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.ClientConsensusStates", len)?;
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        if !self.consensus_states.is_empty() {
+            struct_ser.serialize_field("consensusStates", &self.consensus_states)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ClientConsensusStates {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "client_id",
+            "clientId",
+            "consensus_states",
+            "consensusStates",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientId,
+            ConsensusStates,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            "consensusStates" | "consensus_states" => {
+                                Ok(GeneratedField::ConsensusStates)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ClientConsensusStates;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.ClientConsensusStates")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<ClientConsensusStates, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut client_id__ = None;
+                let mut consensus_states__ = 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::ConsensusStates => {
+                            if consensus_states__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("consensusStates"));
+                            }
+                            consensus_states__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(ClientConsensusStates {
+                    client_id: client_id__.unwrap_or_default(),
+                    consensus_states: consensus_states__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.ClientConsensusStates",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for ClientUpdateProposal {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.title.is_empty() {
+            len += 1;
+        }
+        if !self.description.is_empty() {
+            len += 1;
+        }
+        if !self.subject_client_id.is_empty() {
+            len += 1;
+        }
+        if !self.substitute_client_id.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.ClientUpdateProposal", len)?;
+        if !self.title.is_empty() {
+            struct_ser.serialize_field("title", &self.title)?;
+        }
+        if !self.description.is_empty() {
+            struct_ser.serialize_field("description", &self.description)?;
+        }
+        if !self.subject_client_id.is_empty() {
+            struct_ser.serialize_field("subjectClientId", &self.subject_client_id)?;
+        }
+        if !self.substitute_client_id.is_empty() {
+            struct_ser.serialize_field("substituteClientId", &self.substitute_client_id)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ClientUpdateProposal {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    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,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    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 std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.ClientUpdateProposal")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<ClientUpdateProposal, V::Error>
+            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,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for ConsensusStateWithHeight {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.height.is_some() {
+            len += 1;
+        }
+        if self.consensus_state.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.ConsensusStateWithHeight", len)?;
+        if let Some(v) = self.height.as_ref() {
+            struct_ser.serialize_field("height", v)?;
+        }
+        if let Some(v) = self.consensus_state.as_ref() {
+            struct_ser.serialize_field("consensusState", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ConsensusStateWithHeight {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["height", "consensus_state", "consensusState"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Height,
+            ConsensusState,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "height" => Ok(GeneratedField::Height),
+                            "consensusState" | "consensus_state" => {
+                                Ok(GeneratedField::ConsensusState)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ConsensusStateWithHeight;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.ConsensusStateWithHeight")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<ConsensusStateWithHeight, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut height__ = None;
+                let mut consensus_state__ = 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__ = map_.next_value()?;
+                        }
+                        GeneratedField::ConsensusState => {
+                            if consensus_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("consensusState"));
+                            }
+                            consensus_state__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(ConsensusStateWithHeight {
+                    height: height__,
+                    consensus_state: consensus_state__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.ConsensusStateWithHeight",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for GenesisMetadata {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.key.is_empty() {
+            len += 1;
+        }
+        if !self.value.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.GenesisMetadata", len)?;
+        if !self.key.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?;
+        }
+        if !self.value.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "value",
+                pbjson::private::base64::encode(&self.value).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for GenesisMetadata {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["key", "value"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Key,
+            Value,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "key" => Ok(GeneratedField::Key),
+                            "value" => Ok(GeneratedField::Value),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = GenesisMetadata;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.GenesisMetadata")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GenesisMetadata, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut key__ = None;
+                let mut value__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Key => {
+                            if key__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("key"));
+                            }
+                            key__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("value"));
+                            }
+                            value__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(GenesisMetadata {
+                    key: key__.unwrap_or_default(),
+                    value: value__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.GenesisMetadata",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for GenesisState {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.clients.is_empty() {
+            len += 1;
+        }
+        if !self.clients_consensus.is_empty() {
+            len += 1;
+        }
+        if !self.clients_metadata.is_empty() {
+            len += 1;
+        }
+        if self.params.is_some() {
+            len += 1;
+        }
+        if self.create_localhost {
+            len += 1;
+        }
+        if self.next_client_sequence != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ibc.core.client.v1.GenesisState", len)?;
+        if !self.clients.is_empty() {
+            struct_ser.serialize_field("clients", &self.clients)?;
+        }
+        if !self.clients_consensus.is_empty() {
+            struct_ser.serialize_field("clientsConsensus", &self.clients_consensus)?;
+        }
+        if !self.clients_metadata.is_empty() {
+            struct_ser.serialize_field("clientsMetadata", &self.clients_metadata)?;
+        }
+        if let Some(v) = self.params.as_ref() {
+            struct_ser.serialize_field("params", v)?;
+        }
+        if self.create_localhost {
+            struct_ser.serialize_field("createLocalhost", &self.create_localhost)?;
+        }
+        if self.next_client_sequence != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "nextClientSequence",
+                ToString::to_string(&self.next_client_sequence).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for GenesisState {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "clients",
+            "clients_consensus",
+            "clientsConsensus",
+            "clients_metadata",
+            "clientsMetadata",
+            "params",
+            "create_localhost",
+            "createLocalhost",
+            "next_client_sequence",
+            "nextClientSequence",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Clients,
+            ClientsConsensus,
+            ClientsMetadata,
+            Params,
+            CreateLocalhost,
+            NextClientSequence,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clients" => Ok(GeneratedField::Clients),
+                            "clientsConsensus" | "clients_consensus" => {
+                                Ok(GeneratedField::ClientsConsensus)
+                            }
+                            "clientsMetadata" | "clients_metadata" => {
+                                Ok(GeneratedField::ClientsMetadata)
+                            }
+                            "params" => Ok(GeneratedField::Params),
+                            "createLocalhost" | "create_localhost" => {
+                                Ok(GeneratedField::CreateLocalhost)
+                            }
+                            "nextClientSequence" | "next_client_sequence" => {
+                                Ok(GeneratedField::NextClientSequence)
+                            }
+                            _ => 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 std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.GenesisState")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GenesisState, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut clients__ = None;
+                let mut clients_consensus__ = None;
+                let mut clients_metadata__ = None;
+                let mut params__ = None;
+                let mut create_localhost__ = None;
+                let mut next_client_sequence__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Clients => {
+                            if clients__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("clients"));
+                            }
+                            clients__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ClientsConsensus => {
+                            if clients_consensus__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("clientsConsensus"));
+                            }
+                            clients_consensus__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ClientsMetadata => {
+                            if clients_metadata__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("clientsMetadata"));
+                            }
+                            clients_metadata__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Params => {
+                            if params__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("params"));
+                            }
+                            params__ = map_.next_value()?;
+                        }
+                        GeneratedField::CreateLocalhost => {
+                            if create_localhost__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("createLocalhost"));
+                            }
+                            create_localhost__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::NextClientSequence => {
+                            if next_client_sequence__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "nextClientSequence",
+                                ));
+                            }
+                            next_client_sequence__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(GenesisState {
+                    clients: clients__.unwrap_or_default(),
+                    clients_consensus: clients_consensus__.unwrap_or_default(),
+                    clients_metadata: clients_metadata__.unwrap_or_default(),
+                    params: params__,
+                    create_localhost: create_localhost__.unwrap_or_default(),
+                    next_client_sequence: next_client_sequence__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("ibc.core.client.v1.GenesisState", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Height {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.revision_number != 0 {
+            len += 1;
+        }
+        if self.revision_height != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ibc.core.client.v1.Height", len)?;
+        if self.revision_number != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "revisionNumber",
+                ToString::to_string(&self.revision_number).as_str(),
+            )?;
+        }
+        if self.revision_height != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "revisionHeight",
+                ToString::to_string(&self.revision_height).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Height {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "revision_number",
+            "revisionNumber",
+            "revision_height",
+            "revisionHeight",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            RevisionNumber,
+            RevisionHeight,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "revisionNumber" | "revision_number" => {
+                                Ok(GeneratedField::RevisionNumber)
+                            }
+                            "revisionHeight" | "revision_height" => {
+                                Ok(GeneratedField::RevisionHeight)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Height;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.Height")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Height, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut revision_number__ = None;
+                let mut revision_height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::RevisionNumber => {
+                            if revision_number__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("revisionNumber"));
+                            }
+                            revision_number__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::RevisionHeight => {
+                            if revision_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("revisionHeight"));
+                            }
+                            revision_height__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(Height {
+                    revision_number: revision_number__.unwrap_or_default(),
+                    revision_height: revision_height__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("ibc.core.client.v1.Height", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for IdentifiedClientState {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        if self.client_state.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.IdentifiedClientState", len)?;
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        if let Some(v) = self.client_state.as_ref() {
+            struct_ser.serialize_field("clientState", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for IdentifiedClientState {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["client_id", "clientId", "client_state", "clientState"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientId,
+            ClientState,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            "clientState" | "client_state" => Ok(GeneratedField::ClientState),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = IdentifiedClientState;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.IdentifiedClientState")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<IdentifiedClientState, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut client_id__ = None;
+                let mut client_state__ = 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::ClientState => {
+                            if client_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("clientState"));
+                            }
+                            client_state__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(IdentifiedClientState {
+                    client_id: client_id__.unwrap_or_default(),
+                    client_state: client_state__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.IdentifiedClientState",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for IdentifiedGenesisMetadata {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        if !self.client_metadata.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.IdentifiedGenesisMetadata", len)?;
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        if !self.client_metadata.is_empty() {
+            struct_ser.serialize_field("clientMetadata", &self.client_metadata)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for IdentifiedGenesisMetadata {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["client_id", "clientId", "client_metadata", "clientMetadata"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientId,
+            ClientMetadata,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            "clientMetadata" | "client_metadata" => {
+                                Ok(GeneratedField::ClientMetadata)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = IdentifiedGenesisMetadata;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.IdentifiedGenesisMetadata")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<IdentifiedGenesisMetadata, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut client_id__ = None;
+                let mut client_metadata__ = 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::ClientMetadata => {
+                            if client_metadata__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("clientMetadata"));
+                            }
+                            client_metadata__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(IdentifiedGenesisMetadata {
+                    client_id: client_id__.unwrap_or_default(),
+                    client_metadata: client_metadata__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.IdentifiedGenesisMetadata",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgCreateClient {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.client_state.is_some() {
+            len += 1;
+        }
+        if self.consensus_state.is_some() {
+            len += 1;
+        }
+        if !self.signer.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.MsgCreateClient", len)?;
+        if let Some(v) = self.client_state.as_ref() {
+            struct_ser.serialize_field("clientState", v)?;
+        }
+        if let Some(v) = self.consensus_state.as_ref() {
+            struct_ser.serialize_field("consensusState", v)?;
+        }
+        if !self.signer.is_empty() {
+            struct_ser.serialize_field("signer", &self.signer)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgCreateClient {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "client_state",
+            "clientState",
+            "consensus_state",
+            "consensusState",
+            "signer",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientState,
+            ConsensusState,
+            Signer,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientState" | "client_state" => Ok(GeneratedField::ClientState),
+                            "consensusState" | "consensus_state" => {
+                                Ok(GeneratedField::ConsensusState)
+                            }
+                            "signer" => Ok(GeneratedField::Signer),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgCreateClient;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.MsgCreateClient")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MsgCreateClient, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut client_state__ = None;
+                let mut consensus_state__ = None;
+                let mut signer__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ClientState => {
+                            if client_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("clientState"));
+                            }
+                            client_state__ = map_.next_value()?;
+                        }
+                        GeneratedField::ConsensusState => {
+                            if consensus_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("consensusState"));
+                            }
+                            consensus_state__ = map_.next_value()?;
+                        }
+                        GeneratedField::Signer => {
+                            if signer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signer"));
+                            }
+                            signer__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgCreateClient {
+                    client_state: client_state__,
+                    consensus_state: consensus_state__,
+                    signer: signer__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.MsgCreateClient",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgCreateClientResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.MsgCreateClientResponse", len)?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgCreateClientResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgCreateClientResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.MsgCreateClientResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgCreateClientResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(MsgCreateClientResponse {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.MsgCreateClientResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgSubmitMisbehaviour {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        if self.misbehaviour.is_some() {
+            len += 1;
+        }
+        if !self.signer.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.MsgSubmitMisbehaviour", len)?;
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        if let Some(v) = self.misbehaviour.as_ref() {
+            struct_ser.serialize_field("misbehaviour", v)?;
+        }
+        if !self.signer.is_empty() {
+            struct_ser.serialize_field("signer", &self.signer)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgSubmitMisbehaviour {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["client_id", "clientId", "misbehaviour", "signer"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientId,
+            Misbehaviour,
+            Signer,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            "misbehaviour" => Ok(GeneratedField::Misbehaviour),
+                            "signer" => Ok(GeneratedField::Signer),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgSubmitMisbehaviour;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.MsgSubmitMisbehaviour")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgSubmitMisbehaviour, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut client_id__ = None;
+                let mut misbehaviour__ = None;
+                let mut signer__ = 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::Misbehaviour => {
+                            if misbehaviour__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("misbehaviour"));
+                            }
+                            misbehaviour__ = map_.next_value()?;
+                        }
+                        GeneratedField::Signer => {
+                            if signer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signer"));
+                            }
+                            signer__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgSubmitMisbehaviour {
+                    client_id: client_id__.unwrap_or_default(),
+                    misbehaviour: misbehaviour__,
+                    signer: signer__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.MsgSubmitMisbehaviour",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgSubmitMisbehaviourResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.MsgSubmitMisbehaviourResponse", len)?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgSubmitMisbehaviourResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgSubmitMisbehaviourResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.MsgSubmitMisbehaviourResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgSubmitMisbehaviourResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(MsgSubmitMisbehaviourResponse {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.MsgSubmitMisbehaviourResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgUpdateClient {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        if self.header.is_some() {
+            len += 1;
+        }
+        if !self.signer.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.MsgUpdateClient", len)?;
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        if let Some(v) = self.header.as_ref() {
+            struct_ser.serialize_field("header", v)?;
+        }
+        if !self.signer.is_empty() {
+            struct_ser.serialize_field("signer", &self.signer)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgUpdateClient {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["client_id", "clientId", "header", "signer"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientId,
+            Header,
+            Signer,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            "header" => Ok(GeneratedField::Header),
+                            "signer" => Ok(GeneratedField::Signer),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgUpdateClient;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.MsgUpdateClient")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MsgUpdateClient, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut client_id__ = None;
+                let mut header__ = None;
+                let mut signer__ = 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::Header => {
+                            if header__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("header"));
+                            }
+                            header__ = map_.next_value()?;
+                        }
+                        GeneratedField::Signer => {
+                            if signer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signer"));
+                            }
+                            signer__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgUpdateClient {
+                    client_id: client_id__.unwrap_or_default(),
+                    header: header__,
+                    signer: signer__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.MsgUpdateClient",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgUpdateClientResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.MsgUpdateClientResponse", len)?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgUpdateClientResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgUpdateClientResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.MsgUpdateClientResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgUpdateClientResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(MsgUpdateClientResponse {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.MsgUpdateClientResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgUpgradeClient {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        if self.client_state.is_some() {
+            len += 1;
+        }
+        if self.consensus_state.is_some() {
+            len += 1;
+        }
+        if !self.proof_upgrade_client.is_empty() {
+            len += 1;
+        }
+        if !self.proof_upgrade_consensus_state.is_empty() {
+            len += 1;
+        }
+        if !self.signer.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.MsgUpgradeClient", len)?;
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        if let Some(v) = self.client_state.as_ref() {
+            struct_ser.serialize_field("clientState", v)?;
+        }
+        if let Some(v) = self.consensus_state.as_ref() {
+            struct_ser.serialize_field("consensusState", v)?;
+        }
+        if !self.proof_upgrade_client.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "proofUpgradeClient",
+                pbjson::private::base64::encode(&self.proof_upgrade_client).as_str(),
+            )?;
+        }
+        if !self.proof_upgrade_consensus_state.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "proofUpgradeConsensusState",
+                pbjson::private::base64::encode(&self.proof_upgrade_consensus_state).as_str(),
+            )?;
+        }
+        if !self.signer.is_empty() {
+            struct_ser.serialize_field("signer", &self.signer)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgUpgradeClient {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "client_id",
+            "clientId",
+            "client_state",
+            "clientState",
+            "consensus_state",
+            "consensusState",
+            "proof_upgrade_client",
+            "proofUpgradeClient",
+            "proof_upgrade_consensus_state",
+            "proofUpgradeConsensusState",
+            "signer",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientId,
+            ClientState,
+            ConsensusState,
+            ProofUpgradeClient,
+            ProofUpgradeConsensusState,
+            Signer,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            "clientState" | "client_state" => Ok(GeneratedField::ClientState),
+                            "consensusState" | "consensus_state" => {
+                                Ok(GeneratedField::ConsensusState)
+                            }
+                            "proofUpgradeClient" | "proof_upgrade_client" => {
+                                Ok(GeneratedField::ProofUpgradeClient)
+                            }
+                            "proofUpgradeConsensusState" | "proof_upgrade_consensus_state" => {
+                                Ok(GeneratedField::ProofUpgradeConsensusState)
+                            }
+                            "signer" => Ok(GeneratedField::Signer),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgUpgradeClient;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.MsgUpgradeClient")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MsgUpgradeClient, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut client_id__ = None;
+                let mut client_state__ = None;
+                let mut consensus_state__ = None;
+                let mut proof_upgrade_client__ = None;
+                let mut proof_upgrade_consensus_state__ = None;
+                let mut signer__ = 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::ClientState => {
+                            if client_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("clientState"));
+                            }
+                            client_state__ = map_.next_value()?;
+                        }
+                        GeneratedField::ConsensusState => {
+                            if consensus_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("consensusState"));
+                            }
+                            consensus_state__ = map_.next_value()?;
+                        }
+                        GeneratedField::ProofUpgradeClient => {
+                            if proof_upgrade_client__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "proofUpgradeClient",
+                                ));
+                            }
+                            proof_upgrade_client__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::ProofUpgradeConsensusState => {
+                            if proof_upgrade_consensus_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "proofUpgradeConsensusState",
+                                ));
+                            }
+                            proof_upgrade_consensus_state__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Signer => {
+                            if signer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signer"));
+                            }
+                            signer__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgUpgradeClient {
+                    client_id: client_id__.unwrap_or_default(),
+                    client_state: client_state__,
+                    consensus_state: consensus_state__,
+                    proof_upgrade_client: proof_upgrade_client__.unwrap_or_default(),
+                    proof_upgrade_consensus_state: proof_upgrade_consensus_state__
+                        .unwrap_or_default(),
+                    signer: signer__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.MsgUpgradeClient",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgUpgradeClientResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.MsgUpgradeClientResponse", len)?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgUpgradeClientResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgUpgradeClientResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.MsgUpgradeClientResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgUpgradeClientResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(MsgUpgradeClientResponse {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.MsgUpgradeClientResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Params {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.allowed_clients.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ibc.core.client.v1.Params", len)?;
+        if !self.allowed_clients.is_empty() {
+            struct_ser.serialize_field("allowedClients", &self.allowed_clients)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Params {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["allowed_clients", "allowedClients"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            AllowedClients,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "allowedClients" | "allowed_clients" => {
+                                Ok(GeneratedField::AllowedClients)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Params;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.Params")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Params, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut allowed_clients__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::AllowedClients => {
+                            if allowed_clients__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("allowedClients"));
+                            }
+                            allowed_clients__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(Params {
+                    allowed_clients: allowed_clients__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("ibc.core.client.v1.Params", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryClientParamsRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.QueryClientParamsRequest", len)?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryClientParamsRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryClientParamsRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.QueryClientParamsRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryClientParamsRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(QueryClientParamsRequest {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.QueryClientParamsRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryClientParamsResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.params.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.QueryClientParamsResponse", len)?;
+        if let Some(v) = self.params.as_ref() {
+            struct_ser.serialize_field("params", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryClientParamsResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["params"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Params,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "params" => Ok(GeneratedField::Params),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryClientParamsResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.QueryClientParamsResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryClientParamsResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut params__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Params => {
+                            if params__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("params"));
+                            }
+                            params__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryClientParamsResponse { params: params__ })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.QueryClientParamsResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryClientStateRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.QueryClientStateRequest", len)?;
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryClientStateRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["client_id", "clientId"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientId,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryClientStateRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.QueryClientStateRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryClientStateRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                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(QueryClientStateRequest {
+                    client_id: client_id__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.QueryClientStateRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryClientStateResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.client_state.is_some() {
+            len += 1;
+        }
+        if !self.proof.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.QueryClientStateResponse", len)?;
+        if let Some(v) = self.client_state.as_ref() {
+            struct_ser.serialize_field("clientState", v)?;
+        }
+        if !self.proof.is_empty() {
+            #[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)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryClientStateResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "client_state",
+            "clientState",
+            "proof",
+            "proof_height",
+            "proofHeight",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientState,
+            Proof,
+            ProofHeight,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientState" | "client_state" => Ok(GeneratedField::ClientState),
+                            "proof" => Ok(GeneratedField::Proof),
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryClientStateResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.QueryClientStateResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryClientStateResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut client_state__ = None;
+                let mut proof__ = None;
+                let mut proof_height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ClientState => {
+                            if client_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("clientState"));
+                            }
+                            client_state__ = 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()?;
+                        }
+                    }
+                }
+                Ok(QueryClientStateResponse {
+                    client_state: client_state__,
+                    proof: proof__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.QueryClientStateResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryClientStatesRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.pagination.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.QueryClientStatesRequest", len)?;
+        if let Some(v) = self.pagination.as_ref() {
+            struct_ser.serialize_field("pagination", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryClientStatesRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["pagination"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Pagination,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    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 = QueryClientStatesRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.QueryClientStatesRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryClientStatesRequest, V::Error>
+            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(QueryClientStatesRequest {
+                    pagination: pagination__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.QueryClientStatesRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryClientStatesResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.client_states.is_empty() {
+            len += 1;
+        }
+        if self.pagination.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.QueryClientStatesResponse", len)?;
+        if !self.client_states.is_empty() {
+            struct_ser.serialize_field("clientStates", &self.client_states)?;
+        }
+        if let Some(v) = self.pagination.as_ref() {
+            struct_ser.serialize_field("pagination", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryClientStatesResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["client_states", "clientStates", "pagination"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientStates,
+            Pagination,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientStates" | "client_states" => Ok(GeneratedField::ClientStates),
+                            "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 = QueryClientStatesResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.QueryClientStatesResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryClientStatesResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut client_states__ = None;
+                let mut pagination__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ClientStates => {
+                            if client_states__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("clientStates"));
+                            }
+                            client_states__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Pagination => {
+                            if pagination__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("pagination"));
+                            }
+                            pagination__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryClientStatesResponse {
+                    client_states: client_states__.unwrap_or_default(),
+                    pagination: pagination__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.QueryClientStatesResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryClientStatusRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.QueryClientStatusRequest", len)?;
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryClientStatusRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["client_id", "clientId"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientId,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryClientStatusRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.QueryClientStatusRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryClientStatusRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                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(QueryClientStatusRequest {
+                    client_id: client_id__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.QueryClientStatusRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryClientStatusResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.status.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.QueryClientStatusResponse", len)?;
+        if !self.status.is_empty() {
+            struct_ser.serialize_field("status", &self.status)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryClientStatusResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["status"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Status,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "status" => Ok(GeneratedField::Status),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryClientStatusResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.QueryClientStatusResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryClientStatusResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut status__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Status => {
+                            if status__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("status"));
+                            }
+                            status__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryClientStatusResponse {
+                    status: status__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.QueryClientStatusResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryConsensusStateHeightsRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        if self.pagination.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.core.client.v1.QueryConsensusStateHeightsRequest", len)?;
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        if let Some(v) = self.pagination.as_ref() {
+            struct_ser.serialize_field("pagination", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryConsensusStateHeightsRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["client_id", "clientId", "pagination"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientId,
+            Pagination,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            "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 = QueryConsensusStateHeightsRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.QueryConsensusStateHeightsRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryConsensusStateHeightsRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut client_id__ = None;
+                let mut pagination__ = 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::Pagination => {
+                            if pagination__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("pagination"));
+                            }
+                            pagination__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryConsensusStateHeightsRequest {
+                    client_id: client_id__.unwrap_or_default(),
+                    pagination: pagination__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.QueryConsensusStateHeightsRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryConsensusStateHeightsResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.consensus_state_heights.is_empty() {
+            len += 1;
+        }
+        if self.pagination.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.core.client.v1.QueryConsensusStateHeightsResponse", len)?;
+        if !self.consensus_state_heights.is_empty() {
+            struct_ser.serialize_field("consensusStateHeights", &self.consensus_state_heights)?;
+        }
+        if let Some(v) = self.pagination.as_ref() {
+            struct_ser.serialize_field("pagination", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryConsensusStateHeightsResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "consensus_state_heights",
+            "consensusStateHeights",
+            "pagination",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ConsensusStateHeights,
+            Pagination,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "consensusStateHeights" | "consensus_state_heights" => {
+                                Ok(GeneratedField::ConsensusStateHeights)
+                            }
+                            "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 = QueryConsensusStateHeightsResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.QueryConsensusStateHeightsResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryConsensusStateHeightsResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut consensus_state_heights__ = None;
+                let mut pagination__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ConsensusStateHeights => {
+                            if consensus_state_heights__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "consensusStateHeights",
+                                ));
+                            }
+                            consensus_state_heights__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Pagination => {
+                            if pagination__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("pagination"));
+                            }
+                            pagination__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryConsensusStateHeightsResponse {
+                    consensus_state_heights: consensus_state_heights__.unwrap_or_default(),
+                    pagination: pagination__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.QueryConsensusStateHeightsResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryConsensusStateRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        if self.revision_number != 0 {
+            len += 1;
+        }
+        if self.revision_height != 0 {
+            len += 1;
+        }
+        if self.latest_height {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.QueryConsensusStateRequest", len)?;
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        if self.revision_number != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "revisionNumber",
+                ToString::to_string(&self.revision_number).as_str(),
+            )?;
+        }
+        if self.revision_height != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "revisionHeight",
+                ToString::to_string(&self.revision_height).as_str(),
+            )?;
+        }
+        if self.latest_height {
+            struct_ser.serialize_field("latestHeight", &self.latest_height)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryConsensusStateRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "client_id",
+            "clientId",
+            "revision_number",
+            "revisionNumber",
+            "revision_height",
+            "revisionHeight",
+            "latest_height",
+            "latestHeight",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientId,
+            RevisionNumber,
+            RevisionHeight,
+            LatestHeight,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            "revisionNumber" | "revision_number" => {
+                                Ok(GeneratedField::RevisionNumber)
+                            }
+                            "revisionHeight" | "revision_height" => {
+                                Ok(GeneratedField::RevisionHeight)
+                            }
+                            "latestHeight" | "latest_height" => Ok(GeneratedField::LatestHeight),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryConsensusStateRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.QueryConsensusStateRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryConsensusStateRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut client_id__ = None;
+                let mut revision_number__ = None;
+                let mut revision_height__ = None;
+                let mut latest_height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ClientId => {
+                            if client_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("clientId"));
+                            }
+                            client_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::RevisionNumber => {
+                            if revision_number__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("revisionNumber"));
+                            }
+                            revision_number__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::RevisionHeight => {
+                            if revision_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("revisionHeight"));
+                            }
+                            revision_height__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::LatestHeight => {
+                            if latest_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("latestHeight"));
+                            }
+                            latest_height__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryConsensusStateRequest {
+                    client_id: client_id__.unwrap_or_default(),
+                    revision_number: revision_number__.unwrap_or_default(),
+                    revision_height: revision_height__.unwrap_or_default(),
+                    latest_height: latest_height__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.QueryConsensusStateRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryConsensusStateResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.consensus_state.is_some() {
+            len += 1;
+        }
+        if !self.proof.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.QueryConsensusStateResponse", len)?;
+        if let Some(v) = self.consensus_state.as_ref() {
+            struct_ser.serialize_field("consensusState", v)?;
+        }
+        if !self.proof.is_empty() {
+            #[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)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryConsensusStateResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "consensus_state",
+            "consensusState",
+            "proof",
+            "proof_height",
+            "proofHeight",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ConsensusState,
+            Proof,
+            ProofHeight,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "consensusState" | "consensus_state" => {
+                                Ok(GeneratedField::ConsensusState)
+                            }
+                            "proof" => Ok(GeneratedField::Proof),
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryConsensusStateResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.QueryConsensusStateResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryConsensusStateResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut consensus_state__ = None;
+                let mut proof__ = None;
+                let mut proof_height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ConsensusState => {
+                            if consensus_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("consensusState"));
+                            }
+                            consensus_state__ = 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()?;
+                        }
+                    }
+                }
+                Ok(QueryConsensusStateResponse {
+                    consensus_state: consensus_state__,
+                    proof: proof__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.QueryConsensusStateResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryConsensusStatesRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        if self.pagination.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.QueryConsensusStatesRequest", len)?;
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        if let Some(v) = self.pagination.as_ref() {
+            struct_ser.serialize_field("pagination", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryConsensusStatesRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["client_id", "clientId", "pagination"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientId,
+            Pagination,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            "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 = QueryConsensusStatesRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.QueryConsensusStatesRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryConsensusStatesRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut client_id__ = None;
+                let mut pagination__ = 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::Pagination => {
+                            if pagination__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("pagination"));
+                            }
+                            pagination__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryConsensusStatesRequest {
+                    client_id: client_id__.unwrap_or_default(),
+                    pagination: pagination__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.QueryConsensusStatesRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryConsensusStatesResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.consensus_states.is_empty() {
+            len += 1;
+        }
+        if self.pagination.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.QueryConsensusStatesResponse", len)?;
+        if !self.consensus_states.is_empty() {
+            struct_ser.serialize_field("consensusStates", &self.consensus_states)?;
+        }
+        if let Some(v) = self.pagination.as_ref() {
+            struct_ser.serialize_field("pagination", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryConsensusStatesResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["consensus_states", "consensusStates", "pagination"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ConsensusStates,
+            Pagination,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "consensusStates" | "consensus_states" => {
+                                Ok(GeneratedField::ConsensusStates)
+                            }
+                            "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 = QueryConsensusStatesResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.QueryConsensusStatesResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryConsensusStatesResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut consensus_states__ = None;
+                let mut pagination__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ConsensusStates => {
+                            if consensus_states__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("consensusStates"));
+                            }
+                            consensus_states__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Pagination => {
+                            if pagination__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("pagination"));
+                            }
+                            pagination__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryConsensusStatesResponse {
+                    consensus_states: consensus_states__.unwrap_or_default(),
+                    pagination: pagination__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.QueryConsensusStatesResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryUpgradedClientStateRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser = serializer
+            .serialize_struct("ibc.core.client.v1.QueryUpgradedClientStateRequest", len)?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryUpgradedClientStateRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryUpgradedClientStateRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.QueryUpgradedClientStateRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryUpgradedClientStateRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(QueryUpgradedClientStateRequest {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.QueryUpgradedClientStateRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryUpgradedClientStateResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.upgraded_client_state.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.core.client.v1.QueryUpgradedClientStateResponse", len)?;
+        if let Some(v) = self.upgraded_client_state.as_ref() {
+            struct_ser.serialize_field("upgradedClientState", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryUpgradedClientStateResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["upgraded_client_state", "upgradedClientState"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            UpgradedClientState,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "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 = QueryUpgradedClientStateResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.QueryUpgradedClientStateResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryUpgradedClientStateResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut upgraded_client_state__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::UpgradedClientState => {
+                            if upgraded_client_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "upgradedClientState",
+                                ));
+                            }
+                            upgraded_client_state__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryUpgradedClientStateResponse {
+                    upgraded_client_state: upgraded_client_state__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.QueryUpgradedClientStateResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryUpgradedConsensusStateRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser = serializer
+            .serialize_struct("ibc.core.client.v1.QueryUpgradedConsensusStateRequest", len)?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryUpgradedConsensusStateRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryUpgradedConsensusStateRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.QueryUpgradedConsensusStateRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryUpgradedConsensusStateRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(QueryUpgradedConsensusStateRequest {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.QueryUpgradedConsensusStateRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryUpgradedConsensusStateResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.upgraded_consensus_state.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.core.client.v1.QueryUpgradedConsensusStateResponse",
+            len,
+        )?;
+        if let Some(v) = self.upgraded_consensus_state.as_ref() {
+            struct_ser.serialize_field("upgradedConsensusState", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryUpgradedConsensusStateResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["upgraded_consensus_state", "upgradedConsensusState"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            UpgradedConsensusState,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "upgradedConsensusState" | "upgraded_consensus_state" => {
+                                Ok(GeneratedField::UpgradedConsensusState)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryUpgradedConsensusStateResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.QueryUpgradedConsensusStateResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryUpgradedConsensusStateResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut upgraded_consensus_state__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::UpgradedConsensusState => {
+                            if upgraded_consensus_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "upgradedConsensusState",
+                                ));
+                            }
+                            upgraded_consensus_state__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryUpgradedConsensusStateResponse {
+                    upgraded_consensus_state: upgraded_consensus_state__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.client.v1.QueryUpgradedConsensusStateResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for UpgradeProposal {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.title.is_empty() {
+            len += 1;
+        }
+        if !self.description.is_empty() {
+            len += 1;
+        }
+        if self.plan.is_some() {
+            len += 1;
+        }
+        if self.upgraded_client_state.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.client.v1.UpgradeProposal", len)?;
+        if !self.title.is_empty() {
+            struct_ser.serialize_field("title", &self.title)?;
+        }
+        if !self.description.is_empty() {
+            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()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for UpgradeProposal {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    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,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    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 std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.client.v1.UpgradeProposal")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpgradeProposal, V::Error>
+            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/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.client.v1.tonic.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.client.v1.tonic.rs
new file mode 100644
index 00000000..2b97c4bf
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.client.v1.tonic.rs
@@ -0,0 +1,1256 @@
+// @generated
+/// Generated client implementations.
+#[cfg(feature = "grpc")]
+pub mod query_client {
+    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
+    use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
+    #[derive(Debug, Clone)]
+    pub struct QueryClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    #[cfg(feature = "grpc-transport")]
+    impl QueryClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> QueryClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> QueryClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
+                Into<StdError> + Send + Sync,
+        {
+            QueryClient::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
+        }
+        pub async fn client_state(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryClientStateRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryClientStateResponse>, 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/ClientState");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("ibc.core.client.v1.Query", "ClientState"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn client_states(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryClientStatesRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryClientStatesResponse>, 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/ClientStates");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("ibc.core.client.v1.Query", "ClientStates"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn consensus_state(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryConsensusStateRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryConsensusStateResponse>, 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/ConsensusState");
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.client.v1.Query",
+                "ConsensusState",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn consensus_states(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryConsensusStatesRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryConsensusStatesResponse>, 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/ConsensusStates");
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.client.v1.Query",
+                "ConsensusStates",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn consensus_state_heights(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryConsensusStateHeightsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryConsensusStateHeightsResponse>,
+            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/ConsensusStateHeights",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.client.v1.Query",
+                "ConsensusStateHeights",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn client_status(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryClientStatusRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryClientStatusResponse>, 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/ClientStatus");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("ibc.core.client.v1.Query", "ClientStatus"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn client_params(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryClientParamsRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryClientParamsResponse>, 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/ClientParams");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("ibc.core.client.v1.Query", "ClientParams"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn upgraded_client_state(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryUpgradedClientStateRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryUpgradedClientStateResponse>,
+            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/UpgradedClientState",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.client.v1.Query",
+                "UpgradedClientState",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn upgraded_consensus_state(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryUpgradedConsensusStateRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryUpgradedConsensusStateResponse>,
+            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/UpgradedConsensusState",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.client.v1.Query",
+                "UpgradedConsensusState",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+#[cfg(feature = "grpc")]
+pub mod query_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 QueryServer.
+    #[async_trait]
+    pub trait Query: Send + Sync + 'static {
+        async fn client_state(
+            &self,
+            request: tonic::Request<super::QueryClientStateRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryClientStateResponse>, tonic::Status>;
+        async fn client_states(
+            &self,
+            request: tonic::Request<super::QueryClientStatesRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryClientStatesResponse>, tonic::Status>;
+        async fn consensus_state(
+            &self,
+            request: tonic::Request<super::QueryConsensusStateRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryConsensusStateResponse>, tonic::Status>;
+        async fn consensus_states(
+            &self,
+            request: tonic::Request<super::QueryConsensusStatesRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryConsensusStatesResponse>, tonic::Status>;
+        async fn consensus_state_heights(
+            &self,
+            request: tonic::Request<super::QueryConsensusStateHeightsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryConsensusStateHeightsResponse>,
+            tonic::Status,
+        >;
+        async fn client_status(
+            &self,
+            request: tonic::Request<super::QueryClientStatusRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryClientStatusResponse>, tonic::Status>;
+        async fn client_params(
+            &self,
+            request: tonic::Request<super::QueryClientParamsRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryClientParamsResponse>, tonic::Status>;
+        async fn upgraded_client_state(
+            &self,
+            request: tonic::Request<super::QueryUpgradedClientStateRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryUpgradedClientStateResponse>,
+            tonic::Status,
+        >;
+        async fn upgraded_consensus_state(
+            &self,
+            request: tonic::Request<super::QueryUpgradedConsensusStateRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryUpgradedConsensusStateResponse>,
+            tonic::Status,
+        >;
+    }
+    #[derive(Debug)]
+    pub struct QueryServer<T: Query> {
+        inner: _Inner<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    struct _Inner<T>(Arc<T>);
+    impl<T: Query> QueryServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            let inner = _Inner(inner);
+            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<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
+        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<T, B> tonic::codegen::Service<http::Request<B>> for QueryServer<T>
+    where
+        T: Query,
+        B: Body + Send + 'static,
+        B::Error: Into<StdError> + Send + 'static,
+    {
+        type Response = http::Response<tonic::body::BoxBody>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            let inner = self.inner.clone();
+            match req.uri().path() {
+                "/ibc.core.client.v1.Query/ClientState" => {
+                    #[allow(non_camel_case_types)]
+                    struct ClientStateSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryClientStateRequest> for ClientStateSvc<T> {
+                        type Response = super::QueryClientStateResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryClientStateRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).client_state(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 = ClientStateSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.client.v1.Query/ClientStates" => {
+                    #[allow(non_camel_case_types)]
+                    struct ClientStatesSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryClientStatesRequest> for ClientStatesSvc<T> {
+                        type Response = super::QueryClientStatesResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryClientStatesRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).client_states(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 = ClientStatesSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.client.v1.Query/ConsensusState" => {
+                    #[allow(non_camel_case_types)]
+                    struct ConsensusStateSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryConsensusStateRequest>
+                        for ConsensusStateSvc<T>
+                    {
+                        type Response = super::QueryConsensusStateResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryConsensusStateRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).consensus_state(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 = ConsensusStateSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.client.v1.Query/ConsensusStates" => {
+                    #[allow(non_camel_case_types)]
+                    struct ConsensusStatesSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryConsensusStatesRequest>
+                        for ConsensusStatesSvc<T>
+                    {
+                        type Response = super::QueryConsensusStatesResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryConsensusStatesRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).consensus_states(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 = ConsensusStatesSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.client.v1.Query/ConsensusStateHeights" => {
+                    #[allow(non_camel_case_types)]
+                    struct ConsensusStateHeightsSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query>
+                        tonic::server::UnaryService<super::QueryConsensusStateHeightsRequest>
+                        for ConsensusStateHeightsSvc<T>
+                    {
+                        type Response = super::QueryConsensusStateHeightsResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryConsensusStateHeightsRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut =
+                                async move { (*inner).consensus_state_heights(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 = ConsensusStateHeightsSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.client.v1.Query/ClientStatus" => {
+                    #[allow(non_camel_case_types)]
+                    struct ClientStatusSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryClientStatusRequest> for ClientStatusSvc<T> {
+                        type Response = super::QueryClientStatusResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryClientStatusRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).client_status(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 = ClientStatusSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.client.v1.Query/ClientParams" => {
+                    #[allow(non_camel_case_types)]
+                    struct ClientParamsSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryClientParamsRequest> for ClientParamsSvc<T> {
+                        type Response = super::QueryClientParamsResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryClientParamsRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).client_params(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 = ClientParamsSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.client.v1.Query/UpgradedClientState" => {
+                    #[allow(non_camel_case_types)]
+                    struct UpgradedClientStateSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query>
+                        tonic::server::UnaryService<super::QueryUpgradedClientStateRequest>
+                        for UpgradedClientStateSvc<T>
+                    {
+                        type Response = super::QueryUpgradedClientStateResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryUpgradedClientStateRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).upgraded_client_state(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 = UpgradedClientStateSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.client.v1.Query/UpgradedConsensusState" => {
+                    #[allow(non_camel_case_types)]
+                    struct UpgradedConsensusStateSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query>
+                        tonic::server::UnaryService<super::QueryUpgradedConsensusStateRequest>
+                        for UpgradedConsensusStateSvc<T>
+                    {
+                        type Response = super::QueryUpgradedConsensusStateResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryUpgradedConsensusStateRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut =
+                                async move { (*inner).upgraded_consensus_state(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 = UpgradedConsensusStateSvc(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", "12")
+                        .header("content-type", "application/grpc")
+                        .body(empty_body())
+                        .unwrap())
+                }),
+            }
+        }
+    }
+    impl<T: Query> Clone for QueryServer<T> {
+        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<T: Query> Clone for _Inner<T> {
+        fn clone(&self) -> Self {
+            Self(Arc::clone(&self.0))
+        }
+    }
+    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "{:?}", self.0)
+        }
+    }
+    impl<T: Query> tonic::server::NamedService for QueryServer<T> {
+        const NAME: &'static str = "ibc.core.client.v1.Query";
+    }
+}
+/// Generated client implementations.
+#[cfg(feature = "grpc")]
+pub mod msg_client {
+    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
+    use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
+    #[derive(Debug, Clone)]
+    pub struct MsgClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    #[cfg(feature = "grpc-transport")]
+    impl MsgClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> MsgClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(inner: T, interceptor: F) -> MsgClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
+                Into<StdError> + Send + Sync,
+        {
+            MsgClient::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
+        }
+        pub async fn create_client(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgCreateClient>,
+        ) -> std::result::Result<tonic::Response<super::MsgCreateClientResponse>, 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.Msg/CreateClient");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("ibc.core.client.v1.Msg", "CreateClient"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn update_client(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgUpdateClient>,
+        ) -> std::result::Result<tonic::Response<super::MsgUpdateClientResponse>, 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.Msg/UpdateClient");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("ibc.core.client.v1.Msg", "UpdateClient"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn upgrade_client(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgUpgradeClient>,
+        ) -> std::result::Result<tonic::Response<super::MsgUpgradeClientResponse>, 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.Msg/UpgradeClient");
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("ibc.core.client.v1.Msg", "UpgradeClient"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn submit_misbehaviour(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgSubmitMisbehaviour>,
+        ) -> std::result::Result<tonic::Response<super::MsgSubmitMisbehaviourResponse>, 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.Msg/SubmitMisbehaviour");
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.client.v1.Msg",
+                "SubmitMisbehaviour",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+#[cfg(feature = "grpc")]
+pub mod msg_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 MsgServer.
+    #[async_trait]
+    pub trait Msg: Send + Sync + 'static {
+        async fn create_client(
+            &self,
+            request: tonic::Request<super::MsgCreateClient>,
+        ) -> std::result::Result<tonic::Response<super::MsgCreateClientResponse>, tonic::Status>;
+        async fn update_client(
+            &self,
+            request: tonic::Request<super::MsgUpdateClient>,
+        ) -> std::result::Result<tonic::Response<super::MsgUpdateClientResponse>, tonic::Status>;
+        async fn upgrade_client(
+            &self,
+            request: tonic::Request<super::MsgUpgradeClient>,
+        ) -> std::result::Result<tonic::Response<super::MsgUpgradeClientResponse>, tonic::Status>;
+        async fn submit_misbehaviour(
+            &self,
+            request: tonic::Request<super::MsgSubmitMisbehaviour>,
+        ) -> std::result::Result<tonic::Response<super::MsgSubmitMisbehaviourResponse>, tonic::Status>;
+    }
+    #[derive(Debug)]
+    pub struct MsgServer<T: Msg> {
+        inner: _Inner<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    struct _Inner<T>(Arc<T>);
+    impl<T: Msg> MsgServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            let inner = _Inner(inner);
+            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<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
+        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<T, B> tonic::codegen::Service<http::Request<B>> for MsgServer<T>
+    where
+        T: Msg,
+        B: Body + Send + 'static,
+        B::Error: Into<StdError> + Send + 'static,
+    {
+        type Response = http::Response<tonic::body::BoxBody>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            let inner = self.inner.clone();
+            match req.uri().path() {
+                "/ibc.core.client.v1.Msg/CreateClient" => {
+                    #[allow(non_camel_case_types)]
+                    struct CreateClientSvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgCreateClient> for CreateClientSvc<T> {
+                        type Response = super::MsgCreateClientResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgCreateClient>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).create_client(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 = CreateClientSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.client.v1.Msg/UpdateClient" => {
+                    #[allow(non_camel_case_types)]
+                    struct UpdateClientSvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgUpdateClient> for UpdateClientSvc<T> {
+                        type Response = super::MsgUpdateClientResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgUpdateClient>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).update_client(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 = UpdateClientSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.client.v1.Msg/UpgradeClient" => {
+                    #[allow(non_camel_case_types)]
+                    struct UpgradeClientSvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgUpgradeClient> for UpgradeClientSvc<T> {
+                        type Response = super::MsgUpgradeClientResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgUpgradeClient>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).upgrade_client(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 = UpgradeClientSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.client.v1.Msg/SubmitMisbehaviour" => {
+                    #[allow(non_camel_case_types)]
+                    struct SubmitMisbehaviourSvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgSubmitMisbehaviour>
+                        for SubmitMisbehaviourSvc<T>
+                    {
+                        type Response = super::MsgSubmitMisbehaviourResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgSubmitMisbehaviour>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).submit_misbehaviour(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 = SubmitMisbehaviourSvc(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", "12")
+                        .header("content-type", "application/grpc")
+                        .body(empty_body())
+                        .unwrap())
+                }),
+            }
+        }
+    }
+    impl<T: Msg> Clone for MsgServer<T> {
+        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<T: Msg> Clone for _Inner<T> {
+        fn clone(&self) -> Self {
+            Self(Arc::clone(&self.0))
+        }
+    }
+    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "{:?}", self.0)
+        }
+    }
+    impl<T: Msg> tonic::server::NamedService for MsgServer<T> {
+        const NAME: &'static str = "ibc.core.client.v1.Msg";
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.commitment.v1.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.commitment.v1.rs
index b528388c..1bae3176 100644
--- a/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.commitment.v1.rs
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.commitment.v1.rs
@@ -1,4 +1,4 @@
-// This file is @generated by prost-build.
+// @generated
 /// MerkleRoot defines a merkle root hash.
 /// In the Cosmos SDK, the AppHash of a block header becomes the root.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -7,16 +7,6 @@ pub struct MerkleRoot {
     #[prost(bytes = "vec", tag = "1")]
     pub hash: ::prost::alloc::vec::Vec<u8>,
 }
-impl ::prost::Name for MerkleRoot {
-    const NAME: &'static str = "MerkleRoot";
-    const PACKAGE: &'static str = "ibc.core.commitment.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.commitment.v1.MerkleRoot".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.commitment.v1.MerkleRoot".into()
-    }
-}
 /// MerklePrefix is merkle path prefixed to the key.
 /// The constructed key from the Path and the key will be append(Path.KeyPath,
 /// append(Path.KeyPrefix, key...))
@@ -26,16 +16,6 @@ pub struct MerklePrefix {
     #[prost(bytes = "vec", tag = "1")]
     pub key_prefix: ::prost::alloc::vec::Vec<u8>,
 }
-impl ::prost::Name for MerklePrefix {
-    const NAME: &'static str = "MerklePrefix";
-    const PACKAGE: &'static str = "ibc.core.commitment.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.commitment.v1.MerklePrefix".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.commitment.v1.MerklePrefix".into()
-    }
-}
 /// MerklePath is the path used to verify commitment proofs, which can be an
 /// arbitrary structured object (defined by a commitment type).
 /// MerklePath is represented from root-to-leaf
@@ -45,16 +25,6 @@ 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
@@ -66,13 +36,5 @@ pub struct MerkleProof {
     #[prost(message, repeated, tag = "1")]
     pub proofs: ::prost::alloc::vec::Vec<super::super::super::super::ics23::CommitmentProof>,
 }
-impl ::prost::Name for MerkleProof {
-    const NAME: &'static str = "MerkleProof";
-    const PACKAGE: &'static str = "ibc.core.commitment.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.commitment.v1.MerkleProof".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.commitment.v1.MerkleProof".into()
-    }
-}
+include!("ibc.core.commitment.v1.serde.rs");
+// @@protoc_insertion_point(module)
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.commitment.v1.serde.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.commitment.v1.serde.rs
new file mode 100644
index 00000000..e4e0a843
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.commitment.v1.serde.rs
@@ -0,0 +1,413 @@
+// @generated
+#[cfg(feature = "serde")]
+impl serde::Serialize for MerklePath {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.key_path.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.commitment.v1.MerklePath", len)?;
+        if !self.key_path.is_empty() {
+            struct_ser.serialize_field("keyPath", &self.key_path)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MerklePath {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["key_path", "keyPath"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            KeyPath,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    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 std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.commitment.v1.MerklePath")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MerklePath, V::Error>
+            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,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MerklePrefix {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.key_prefix.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.commitment.v1.MerklePrefix", len)?;
+        if !self.key_prefix.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "keyPrefix",
+                pbjson::private::base64::encode(&self.key_prefix).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MerklePrefix {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["key_prefix", "keyPrefix"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            KeyPrefix,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "keyPrefix" | "key_prefix" => Ok(GeneratedField::KeyPrefix),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MerklePrefix;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.commitment.v1.MerklePrefix")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MerklePrefix, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut key_prefix__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::KeyPrefix => {
+                            if key_prefix__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("keyPrefix"));
+                            }
+                            key_prefix__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(MerklePrefix {
+                    key_prefix: key_prefix__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.commitment.v1.MerklePrefix",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MerkleProof {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.proofs.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.commitment.v1.MerkleProof", len)?;
+        if !self.proofs.is_empty() {
+            struct_ser.serialize_field("proofs", &self.proofs)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MerkleProof {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["proofs"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Proofs,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "proofs" => Ok(GeneratedField::Proofs),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MerkleProof;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.commitment.v1.MerkleProof")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MerkleProof, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut proofs__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Proofs => {
+                            if proofs__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofs"));
+                            }
+                            proofs__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MerkleProof {
+                    proofs: proofs__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.commitment.v1.MerkleProof",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MerkleRoot {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.hash.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.commitment.v1.MerkleRoot", len)?;
+        if !self.hash.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("hash", pbjson::private::base64::encode(&self.hash).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MerkleRoot {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["hash"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Hash,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    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 = MerkleRoot;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.commitment.v1.MerkleRoot")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MerkleRoot, V::Error>
+            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::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(MerkleRoot {
+                    hash: hash__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.commitment.v1.MerkleRoot",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.connection.v1.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.connection.v1.rs
index 21f3ed26..6b3c9508 100644
--- a/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.connection.v1.rs
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.connection.v1.rs
@@ -1,4 +1,7 @@
-// This file is @generated by prost-build.
+// @generated
+// ICS03 - Connection Data Structures as defined in
+// <https://github.com/cosmos/ibc/blob/master/spec/core/ics-003-connection-semantics#data-structures>
+
 /// ConnectionEnd defines a stateful object on a chain connected to another
 /// separate one.
 /// NOTE: there must only be 2 defined ConnectionEnds to establish
@@ -25,16 +28,6 @@ pub struct ConnectionEnd {
     #[prost(uint64, tag = "5")]
     pub delay_period: u64,
 }
-impl ::prost::Name for ConnectionEnd {
-    const NAME: &'static str = "ConnectionEnd";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.ConnectionEnd".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.ConnectionEnd".into()
-    }
-}
 /// IdentifiedConnection defines a connection with additional connection
 /// identifier field.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -60,16 +53,6 @@ pub struct IdentifiedConnection {
     #[prost(uint64, tag = "6")]
     pub delay_period: u64,
 }
-impl ::prost::Name for IdentifiedConnection {
-    const NAME: &'static str = "IdentifiedConnection";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.IdentifiedConnection".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.IdentifiedConnection".into()
-    }
-}
 /// Counterparty defines the counterparty chain associated with a connection end.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -86,16 +69,6 @@ pub struct Counterparty {
     #[prost(message, optional, tag = "3")]
     pub prefix: ::core::option::Option<super::super::commitment::v1::MerklePrefix>,
 }
-impl ::prost::Name for Counterparty {
-    const NAME: &'static str = "Counterparty";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.Counterparty".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.Counterparty".into()
-    }
-}
 /// ClientPaths define all the connection paths for a client state.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -104,16 +77,6 @@ pub struct ClientPaths {
     #[prost(string, repeated, tag = "1")]
     pub paths: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
 }
-impl ::prost::Name for ClientPaths {
-    const NAME: &'static str = "ClientPaths";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.ClientPaths".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.ClientPaths".into()
-    }
-}
 /// ConnectionPaths define all the connection paths for a given client state.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -125,16 +88,6 @@ pub struct ConnectionPaths {
     #[prost(string, repeated, tag = "2")]
     pub paths: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
 }
-impl ::prost::Name for ConnectionPaths {
-    const NAME: &'static str = "ConnectionPaths";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.ConnectionPaths".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.ConnectionPaths".into()
-    }
-}
 /// Version defines the versioning scheme used to negotiate the IBC verison in
 /// the connection handshake.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -147,19 +100,9 @@ pub struct Version {
     #[prost(string, repeated, tag = "2")]
     pub features: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
 }
-impl ::prost::Name for Version {
-    const NAME: &'static str = "Version";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.Version".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.Version".into()
-    }
-}
 /// Params defines the set of Connection parameters.
 #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Params {
     /// maximum expected time per block (in nanoseconds), used to enforce block delay. This parameter should reflect the
     /// largest amount of time that the chain might reasonably take to produce the next block under normal operating
@@ -167,16 +110,6 @@ pub struct Params {
     #[prost(uint64, tag = "1")]
     pub max_expected_time_per_block: u64,
 }
-impl ::prost::Name for Params {
-    const NAME: &'static str = "Params";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.Params".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.Params".into()
-    }
-}
 /// State defines if a connection is in one of the following states:
 /// INIT, TRYOPEN, OPEN or UNINITIALIZED.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
@@ -216,381 +149,19 @@ impl State {
         }
     }
 }
-/// MsgConnectionOpenInit defines the msg sent by an account on Chain A to
-/// initialize a connection with Chain B.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MsgConnectionOpenInit {
-    #[prost(string, tag = "1")]
-    pub client_id: ::prost::alloc::string::String,
-    #[prost(message, optional, tag = "2")]
-    pub counterparty: ::core::option::Option<Counterparty>,
-    #[prost(message, optional, tag = "3")]
-    pub version: ::core::option::Option<Version>,
-    #[prost(uint64, tag = "4")]
-    pub delay_period: u64,
-    #[prost(string, tag = "5")]
-    pub signer: ::prost::alloc::string::String,
-}
-impl ::prost::Name for MsgConnectionOpenInit {
-    const NAME: &'static str = "MsgConnectionOpenInit";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.MsgConnectionOpenInit".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.MsgConnectionOpenInit".into()
-    }
-}
-/// MsgConnectionOpenInitResponse defines the Msg/ConnectionOpenInit response
-/// type.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct MsgConnectionOpenInitResponse {}
-impl ::prost::Name for MsgConnectionOpenInitResponse {
-    const NAME: &'static str = "MsgConnectionOpenInitResponse";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.MsgConnectionOpenInitResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.MsgConnectionOpenInitResponse".into()
-    }
-}
-/// MsgConnectionOpenTry defines a msg sent by a Relayer to try to open a
-/// connection on Chain B.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MsgConnectionOpenTry {
-    #[prost(string, tag = "1")]
-    pub client_id: ::prost::alloc::string::String,
-    /// Deprecated: this field is unused. Crossing hellos are no longer supported in core IBC.
-    #[deprecated]
-    #[prost(string, tag = "2")]
-    pub previous_connection_id: ::prost::alloc::string::String,
-    #[prost(message, optional, tag = "3")]
-    pub client_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
-    #[prost(message, optional, tag = "4")]
-    pub counterparty: ::core::option::Option<Counterparty>,
-    #[prost(uint64, tag = "5")]
-    pub delay_period: u64,
-    #[prost(message, repeated, tag = "6")]
-    pub counterparty_versions: ::prost::alloc::vec::Vec<Version>,
-    #[prost(message, optional, tag = "7")]
-    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
-    /// proof of the initialization the connection on Chain A: `UNITIALIZED ->
-    /// INIT`
-    #[prost(bytes = "vec", tag = "8")]
-    pub proof_init: ::prost::alloc::vec::Vec<u8>,
-    /// proof of client state included in message
-    #[prost(bytes = "vec", tag = "9")]
-    pub proof_client: ::prost::alloc::vec::Vec<u8>,
-    /// proof of client consensus state
-    #[prost(bytes = "vec", tag = "10")]
-    pub proof_consensus: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, optional, tag = "11")]
-    pub consensus_height: ::core::option::Option<super::super::client::v1::Height>,
-    #[prost(string, tag = "12")]
-    pub signer: ::prost::alloc::string::String,
-}
-impl ::prost::Name for MsgConnectionOpenTry {
-    const NAME: &'static str = "MsgConnectionOpenTry";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.MsgConnectionOpenTry".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.MsgConnectionOpenTry".into()
-    }
-}
-/// MsgConnectionOpenTryResponse defines the Msg/ConnectionOpenTry response type.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct MsgConnectionOpenTryResponse {}
-impl ::prost::Name for MsgConnectionOpenTryResponse {
-    const NAME: &'static str = "MsgConnectionOpenTryResponse";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.MsgConnectionOpenTryResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.MsgConnectionOpenTryResponse".into()
-    }
-}
-/// MsgConnectionOpenAck defines a msg sent by a Relayer to Chain A to
-/// acknowledge the change of connection state to TRYOPEN on Chain B.
+/// GenesisState defines the ibc connection submodule's genesis state.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MsgConnectionOpenAck {
-    #[prost(string, tag = "1")]
-    pub connection_id: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub counterparty_connection_id: ::prost::alloc::string::String,
-    #[prost(message, optional, tag = "3")]
-    pub version: ::core::option::Option<Version>,
+pub struct GenesisState {
+    #[prost(message, repeated, tag = "1")]
+    pub connections: ::prost::alloc::vec::Vec<IdentifiedConnection>,
+    #[prost(message, repeated, tag = "2")]
+    pub client_connection_paths: ::prost::alloc::vec::Vec<ConnectionPaths>,
+    /// the sequence for the next generated connection identifier
+    #[prost(uint64, tag = "3")]
+    pub next_connection_sequence: u64,
     #[prost(message, optional, tag = "4")]
-    pub client_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
-    #[prost(message, optional, tag = "5")]
-    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
-    /// proof of the initialization the connection on Chain B: `UNITIALIZED ->
-    /// TRYOPEN`
-    #[prost(bytes = "vec", tag = "6")]
-    pub proof_try: ::prost::alloc::vec::Vec<u8>,
-    /// proof of client state included in message
-    #[prost(bytes = "vec", tag = "7")]
-    pub proof_client: ::prost::alloc::vec::Vec<u8>,
-    /// proof of client consensus state
-    #[prost(bytes = "vec", tag = "8")]
-    pub proof_consensus: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, optional, tag = "9")]
-    pub consensus_height: ::core::option::Option<super::super::client::v1::Height>,
-    #[prost(string, tag = "10")]
-    pub signer: ::prost::alloc::string::String,
-}
-impl ::prost::Name for MsgConnectionOpenAck {
-    const NAME: &'static str = "MsgConnectionOpenAck";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.MsgConnectionOpenAck".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.MsgConnectionOpenAck".into()
-    }
-}
-/// MsgConnectionOpenAckResponse defines the Msg/ConnectionOpenAck response type.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct MsgConnectionOpenAckResponse {}
-impl ::prost::Name for MsgConnectionOpenAckResponse {
-    const NAME: &'static str = "MsgConnectionOpenAckResponse";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.MsgConnectionOpenAckResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.MsgConnectionOpenAckResponse".into()
-    }
-}
-/// MsgConnectionOpenConfirm defines a msg sent by a Relayer to Chain B to
-/// acknowledge the change of connection state to OPEN on Chain A.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MsgConnectionOpenConfirm {
-    #[prost(string, tag = "1")]
-    pub connection_id: ::prost::alloc::string::String,
-    /// proof for the change of the connection state on Chain A: `INIT -> OPEN`
-    #[prost(bytes = "vec", tag = "2")]
-    pub proof_ack: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, optional, tag = "3")]
-    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
-    #[prost(string, tag = "4")]
-    pub signer: ::prost::alloc::string::String,
-}
-impl ::prost::Name for MsgConnectionOpenConfirm {
-    const NAME: &'static str = "MsgConnectionOpenConfirm";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.MsgConnectionOpenConfirm".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.MsgConnectionOpenConfirm".into()
-    }
-}
-/// MsgConnectionOpenConfirmResponse defines the Msg/ConnectionOpenConfirm
-/// response type.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
-pub struct MsgConnectionOpenConfirmResponse {}
-impl ::prost::Name for MsgConnectionOpenConfirmResponse {
-    const NAME: &'static str = "MsgConnectionOpenConfirmResponse";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.MsgConnectionOpenConfirmResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.MsgConnectionOpenConfirmResponse".into()
-    }
-}
-/// Generated client implementations.
-#[cfg(feature = "grpc")]
-pub mod msg_client {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
-    use tonic::codegen::http::Uri;
-    use tonic::codegen::*;
-    /// Msg defines the ibc/connection Msg service.
-    #[derive(Debug, Clone)]
-    pub struct MsgClient<T> {
-        inner: tonic::client::Grpc<T>,
-    }
-    #[cfg(feature = "grpc-transport")]
-    impl MsgClient<tonic::transport::Channel> {
-        /// Attempt to create a new client by connecting to a given endpoint.
-        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
-        where
-            D: TryInto<tonic::transport::Endpoint>,
-            D::Error: Into<StdError>,
-        {
-            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
-            Ok(Self::new(conn))
-        }
-    }
-    impl<T> MsgClient<T>
-    where
-        T: tonic::client::GrpcService<tonic::body::BoxBody>,
-        T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(inner: T, interceptor: F) -> MsgClient<InterceptedService<T, F>>
-        where
-            F: tonic::service::Interceptor,
-            T::ResponseBody: Default,
-            T: tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
-                Response = http::Response<
-                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
-                >,
-            >,
-            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
-                Into<StdError> + Send + Sync,
-        {
-            MsgClient::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
-        }
-        /// ConnectionOpenInit defines a rpc handler method for MsgConnectionOpenInit.
-        pub async fn connection_open_init(
-            &mut self,
-            request: impl tonic::IntoRequest<super::MsgConnectionOpenInit>,
-        ) -> std::result::Result<tonic::Response<super::MsgConnectionOpenInitResponse>, 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.connection.v1.Msg/ConnectionOpenInit",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.connection.v1.Msg",
-                "ConnectionOpenInit",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// ConnectionOpenTry defines a rpc handler method for MsgConnectionOpenTry.
-        pub async fn connection_open_try(
-            &mut self,
-            request: impl tonic::IntoRequest<super::MsgConnectionOpenTry>,
-        ) -> std::result::Result<tonic::Response<super::MsgConnectionOpenTryResponse>, 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.connection.v1.Msg/ConnectionOpenTry",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.connection.v1.Msg",
-                "ConnectionOpenTry",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// ConnectionOpenAck defines a rpc handler method for MsgConnectionOpenAck.
-        pub async fn connection_open_ack(
-            &mut self,
-            request: impl tonic::IntoRequest<super::MsgConnectionOpenAck>,
-        ) -> std::result::Result<tonic::Response<super::MsgConnectionOpenAckResponse>, 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.connection.v1.Msg/ConnectionOpenAck",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.connection.v1.Msg",
-                "ConnectionOpenAck",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// ConnectionOpenConfirm defines a rpc handler method for
-        /// MsgConnectionOpenConfirm.
-        pub async fn connection_open_confirm(
-            &mut self,
-            request: impl tonic::IntoRequest<super::MsgConnectionOpenConfirm>,
-        ) -> std::result::Result<
-            tonic::Response<super::MsgConnectionOpenConfirmResponse>,
-            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.connection.v1.Msg/ConnectionOpenConfirm",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.connection.v1.Msg",
-                "ConnectionOpenConfirm",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-    }
+    pub params: ::core::option::Option<Params>,
 }
 /// QueryConnectionRequest is the request type for the Query/Connection RPC
 /// method
@@ -601,16 +172,6 @@ pub struct QueryConnectionRequest {
     #[prost(string, tag = "1")]
     pub connection_id: ::prost::alloc::string::String,
 }
-impl ::prost::Name for QueryConnectionRequest {
-    const NAME: &'static str = "QueryConnectionRequest";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.QueryConnectionRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.QueryConnectionRequest".into()
-    }
-}
 /// QueryConnectionResponse is the response type for the Query/Connection RPC
 /// method. Besides the connection end, it includes a proof and the height from
 /// which the proof was retrieved.
@@ -627,16 +188,6 @@ pub struct QueryConnectionResponse {
     #[prost(message, optional, tag = "3")]
     pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
 }
-impl ::prost::Name for QueryConnectionResponse {
-    const NAME: &'static str = "QueryConnectionResponse";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.QueryConnectionResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.QueryConnectionResponse".into()
-    }
-}
 /// QueryConnectionsRequest is the request type for the Query/Connections RPC
 /// method
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -647,16 +198,6 @@ pub struct QueryConnectionsRequest {
         super::super::super::super::cosmos::base::query::v1beta1::PageRequest,
     >,
 }
-impl ::prost::Name for QueryConnectionsRequest {
-    const NAME: &'static str = "QueryConnectionsRequest";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.QueryConnectionsRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.QueryConnectionsRequest".into()
-    }
-}
 /// QueryConnectionsResponse is the response type for the Query/Connections RPC
 /// method.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -674,16 +215,6 @@ pub struct QueryConnectionsResponse {
     #[prost(message, optional, tag = "3")]
     pub height: ::core::option::Option<super::super::client::v1::Height>,
 }
-impl ::prost::Name for QueryConnectionsResponse {
-    const NAME: &'static str = "QueryConnectionsResponse";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.QueryConnectionsResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.QueryConnectionsResponse".into()
-    }
-}
 /// QueryClientConnectionsRequest is the request type for the
 /// Query/ClientConnections RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -693,16 +224,6 @@ pub struct QueryClientConnectionsRequest {
     #[prost(string, tag = "1")]
     pub client_id: ::prost::alloc::string::String,
 }
-impl ::prost::Name for QueryClientConnectionsRequest {
-    const NAME: &'static str = "QueryClientConnectionsRequest";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.QueryClientConnectionsRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.QueryClientConnectionsRequest".into()
-    }
-}
 /// QueryClientConnectionsResponse is the response type for the
 /// Query/ClientConnections RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -718,16 +239,6 @@ pub struct QueryClientConnectionsResponse {
     #[prost(message, optional, tag = "3")]
     pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
 }
-impl ::prost::Name for QueryClientConnectionsResponse {
-    const NAME: &'static str = "QueryClientConnectionsResponse";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.QueryClientConnectionsResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.QueryClientConnectionsResponse".into()
-    }
-}
 /// QueryConnectionClientStateRequest is the request type for the
 /// Query/ConnectionClientState RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -737,16 +248,6 @@ pub struct QueryConnectionClientStateRequest {
     #[prost(string, tag = "1")]
     pub connection_id: ::prost::alloc::string::String,
 }
-impl ::prost::Name for QueryConnectionClientStateRequest {
-    const NAME: &'static str = "QueryConnectionClientStateRequest";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.QueryConnectionClientStateRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.QueryConnectionClientStateRequest".into()
-    }
-}
 /// QueryConnectionClientStateResponse is the response type for the
 /// Query/ConnectionClientState RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -763,16 +264,6 @@ pub struct QueryConnectionClientStateResponse {
     #[prost(message, optional, tag = "3")]
     pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
 }
-impl ::prost::Name for QueryConnectionClientStateResponse {
-    const NAME: &'static str = "QueryConnectionClientStateResponse";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.QueryConnectionClientStateResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.QueryConnectionClientStateResponse".into()
-    }
-}
 /// QueryConnectionConsensusStateRequest is the request type for the
 /// Query/ConnectionConsensusState RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -786,16 +277,6 @@ pub struct QueryConnectionConsensusStateRequest {
     #[prost(uint64, tag = "3")]
     pub revision_height: u64,
 }
-impl ::prost::Name for QueryConnectionConsensusStateRequest {
-    const NAME: &'static str = "QueryConnectionConsensusStateRequest";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.QueryConnectionConsensusStateRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.QueryConnectionConsensusStateRequest".into()
-    }
-}
 /// QueryConnectionConsensusStateResponse is the response type for the
 /// Query/ConnectionConsensusState RPC method
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -814,303 +295,133 @@ pub struct QueryConnectionConsensusStateResponse {
     #[prost(message, optional, tag = "4")]
     pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
 }
-impl ::prost::Name for QueryConnectionConsensusStateResponse {
-    const NAME: &'static str = "QueryConnectionConsensusStateResponse";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.QueryConnectionConsensusStateResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.QueryConnectionConsensusStateResponse".into()
-    }
-}
 /// QueryConnectionParamsRequest is the request type for the Query/ConnectionParams RPC method.
 #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, ::prost::Message)]
 pub struct QueryConnectionParamsRequest {}
-impl ::prost::Name for QueryConnectionParamsRequest {
-    const NAME: &'static str = "QueryConnectionParamsRequest";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.QueryConnectionParamsRequest".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.QueryConnectionParamsRequest".into()
-    }
-}
 /// QueryConnectionParamsResponse is the response type for the Query/ConnectionParams RPC method.
 #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, ::prost::Message)]
 pub struct QueryConnectionParamsResponse {
     /// params defines the parameters of the module.
     #[prost(message, optional, tag = "1")]
     pub params: ::core::option::Option<Params>,
 }
-impl ::prost::Name for QueryConnectionParamsResponse {
-    const NAME: &'static str = "QueryConnectionParamsResponse";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.QueryConnectionParamsResponse".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.QueryConnectionParamsResponse".into()
-    }
+/// MsgConnectionOpenInit defines the msg sent by an account on Chain A to
+/// initialize a connection with Chain B.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgConnectionOpenInit {
+    #[prost(string, tag = "1")]
+    pub client_id: ::prost::alloc::string::String,
+    #[prost(message, optional, tag = "2")]
+    pub counterparty: ::core::option::Option<Counterparty>,
+    #[prost(message, optional, tag = "3")]
+    pub version: ::core::option::Option<Version>,
+    #[prost(uint64, tag = "4")]
+    pub delay_period: u64,
+    #[prost(string, tag = "5")]
+    pub signer: ::prost::alloc::string::String,
 }
-/// Generated client implementations.
-#[cfg(feature = "grpc")]
-pub mod query_client {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
-    use tonic::codegen::http::Uri;
-    use tonic::codegen::*;
-    /// Query provides defines the gRPC querier service
-    #[derive(Debug, Clone)]
-    pub struct QueryClient<T> {
-        inner: tonic::client::Grpc<T>,
-    }
-    #[cfg(feature = "grpc-transport")]
-    impl QueryClient<tonic::transport::Channel> {
-        /// Attempt to create a new client by connecting to a given endpoint.
-        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
-        where
-            D: TryInto<tonic::transport::Endpoint>,
-            D::Error: Into<StdError>,
-        {
-            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
-            Ok(Self::new(conn))
-        }
-    }
-    impl<T> QueryClient<T>
-    where
-        T: tonic::client::GrpcService<tonic::body::BoxBody>,
-        T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(
-            inner: T,
-            interceptor: F,
-        ) -> QueryClient<InterceptedService<T, F>>
-        where
-            F: tonic::service::Interceptor,
-            T::ResponseBody: Default,
-            T: tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
-                Response = http::Response<
-                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
-                >,
-            >,
-            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
-                Into<StdError> + Send + Sync,
-        {
-            QueryClient::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
-        }
-        /// Connection queries an IBC connection end.
-        pub async fn connection(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryConnectionRequest>,
-        ) -> std::result::Result<tonic::Response<super::QueryConnectionResponse>, 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.connection.v1.Query/Connection");
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.connection.v1.Query",
-                "Connection",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// Connections queries all the IBC connections of a chain.
-        pub async fn connections(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryConnectionsRequest>,
-        ) -> std::result::Result<tonic::Response<super::QueryConnectionsResponse>, 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.connection.v1.Query/Connections");
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.connection.v1.Query",
-                "Connections",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// ClientConnections queries the connection paths associated with a client
-        /// state.
-        pub async fn client_connections(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryClientConnectionsRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::QueryClientConnectionsResponse>,
-            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.connection.v1.Query/ClientConnections",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.connection.v1.Query",
-                "ClientConnections",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// ConnectionClientState queries the client state associated with the
-        /// connection.
-        pub async fn connection_client_state(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryConnectionClientStateRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::QueryConnectionClientStateResponse>,
-            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.connection.v1.Query/ConnectionClientState",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.connection.v1.Query",
-                "ConnectionClientState",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// ConnectionConsensusState queries the consensus state associated with the
-        /// connection.
-        pub async fn connection_consensus_state(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryConnectionConsensusStateRequest>,
-        ) -> std::result::Result<
-            tonic::Response<super::QueryConnectionConsensusStateResponse>,
-            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.connection.v1.Query/ConnectionConsensusState",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.connection.v1.Query",
-                "ConnectionConsensusState",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-        /// ConnectionParams queries all parameters of the ibc connection submodule.
-        pub async fn connection_params(
-            &mut self,
-            request: impl tonic::IntoRequest<super::QueryConnectionParamsRequest>,
-        ) -> std::result::Result<tonic::Response<super::QueryConnectionParamsResponse>, 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.connection.v1.Query/ConnectionParams",
-            );
-            let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "ibc.core.connection.v1.Query",
-                "ConnectionParams",
-            ));
-            self.inner.unary(req, path, codec).await
-        }
-    }
+/// MsgConnectionOpenInitResponse defines the Msg/ConnectionOpenInit response
+/// type.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgConnectionOpenInitResponse {}
+/// MsgConnectionOpenTry defines a msg sent by a Relayer to try to open a
+/// connection on Chain B.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgConnectionOpenTry {
+    #[prost(string, tag = "1")]
+    pub client_id: ::prost::alloc::string::String,
+    /// Deprecated: this field is unused. Crossing hellos are no longer supported in core IBC.
+    #[deprecated]
+    #[prost(string, tag = "2")]
+    pub previous_connection_id: ::prost::alloc::string::String,
+    #[prost(message, optional, tag = "3")]
+    pub client_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
+    #[prost(message, optional, tag = "4")]
+    pub counterparty: ::core::option::Option<Counterparty>,
+    #[prost(uint64, tag = "5")]
+    pub delay_period: u64,
+    #[prost(message, repeated, tag = "6")]
+    pub counterparty_versions: ::prost::alloc::vec::Vec<Version>,
+    #[prost(message, optional, tag = "7")]
+    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
+    /// proof of the initialization the connection on Chain A: `UNITIALIZED ->
+    /// INIT`
+    #[prost(bytes = "vec", tag = "8")]
+    pub proof_init: ::prost::alloc::vec::Vec<u8>,
+    /// proof of client state included in message
+    #[prost(bytes = "vec", tag = "9")]
+    pub proof_client: ::prost::alloc::vec::Vec<u8>,
+    /// proof of client consensus state
+    #[prost(bytes = "vec", tag = "10")]
+    pub proof_consensus: ::prost::alloc::vec::Vec<u8>,
+    #[prost(message, optional, tag = "11")]
+    pub consensus_height: ::core::option::Option<super::super::client::v1::Height>,
+    #[prost(string, tag = "12")]
+    pub signer: ::prost::alloc::string::String,
 }
-/// GenesisState defines the ibc connection submodule's genesis state.
+/// MsgConnectionOpenTryResponse defines the Msg/ConnectionOpenTry response type.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GenesisState {
-    #[prost(message, repeated, tag = "1")]
-    pub connections: ::prost::alloc::vec::Vec<IdentifiedConnection>,
-    #[prost(message, repeated, tag = "2")]
-    pub client_connection_paths: ::prost::alloc::vec::Vec<ConnectionPaths>,
-    /// the sequence for the next generated connection identifier
-    #[prost(uint64, tag = "3")]
-    pub next_connection_sequence: u64,
+pub struct MsgConnectionOpenTryResponse {}
+/// MsgConnectionOpenAck defines a msg sent by a Relayer to Chain A to
+/// acknowledge the change of connection state to TRYOPEN on Chain B.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgConnectionOpenAck {
+    #[prost(string, tag = "1")]
+    pub connection_id: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub counterparty_connection_id: ::prost::alloc::string::String,
+    #[prost(message, optional, tag = "3")]
+    pub version: ::core::option::Option<Version>,
     #[prost(message, optional, tag = "4")]
-    pub params: ::core::option::Option<Params>,
+    pub client_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
+    #[prost(message, optional, tag = "5")]
+    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
+    /// proof of the initialization the connection on Chain B: `UNITIALIZED ->
+    /// TRYOPEN`
+    #[prost(bytes = "vec", tag = "6")]
+    pub proof_try: ::prost::alloc::vec::Vec<u8>,
+    /// proof of client state included in message
+    #[prost(bytes = "vec", tag = "7")]
+    pub proof_client: ::prost::alloc::vec::Vec<u8>,
+    /// proof of client consensus state
+    #[prost(bytes = "vec", tag = "8")]
+    pub proof_consensus: ::prost::alloc::vec::Vec<u8>,
+    #[prost(message, optional, tag = "9")]
+    pub consensus_height: ::core::option::Option<super::super::client::v1::Height>,
+    #[prost(string, tag = "10")]
+    pub signer: ::prost::alloc::string::String,
 }
-impl ::prost::Name for GenesisState {
-    const NAME: &'static str = "GenesisState";
-    const PACKAGE: &'static str = "ibc.core.connection.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.connection.v1.GenesisState".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.connection.v1.GenesisState".into()
-    }
+/// MsgConnectionOpenAckResponse defines the Msg/ConnectionOpenAck response type.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgConnectionOpenAckResponse {}
+/// MsgConnectionOpenConfirm defines a msg sent by a Relayer to Chain B to
+/// acknowledge the change of connection state to OPEN on Chain A.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgConnectionOpenConfirm {
+    #[prost(string, tag = "1")]
+    pub connection_id: ::prost::alloc::string::String,
+    /// proof for the change of the connection state on Chain A: `INIT -> OPEN`
+    #[prost(bytes = "vec", tag = "2")]
+    pub proof_ack: ::prost::alloc::vec::Vec<u8>,
+    #[prost(message, optional, tag = "3")]
+    pub proof_height: ::core::option::Option<super::super::client::v1::Height>,
+    #[prost(string, tag = "4")]
+    pub signer: ::prost::alloc::string::String,
 }
+/// MsgConnectionOpenConfirmResponse defines the Msg/ConnectionOpenConfirm
+/// response type.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgConnectionOpenConfirmResponse {}
+include!("ibc.core.connection.v1.serde.rs");
+include!("ibc.core.connection.v1.tonic.rs");
+// @@protoc_insertion_point(module)
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.connection.v1.serde.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.connection.v1.serde.rs
new file mode 100644
index 00000000..b28afb7a
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.connection.v1.serde.rs
@@ -0,0 +1,4037 @@
+// @generated
+#[cfg(feature = "serde")]
+impl serde::Serialize for ClientPaths {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.paths.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.connection.v1.ClientPaths", len)?;
+        if !self.paths.is_empty() {
+            struct_ser.serialize_field("paths", &self.paths)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ClientPaths {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["paths"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Paths,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "paths" => Ok(GeneratedField::Paths),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ClientPaths;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.ClientPaths")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClientPaths, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut paths__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Paths => {
+                            if paths__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("paths"));
+                            }
+                            paths__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(ClientPaths {
+                    paths: paths__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.ClientPaths",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for ConnectionEnd {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        if !self.versions.is_empty() {
+            len += 1;
+        }
+        if self.state != 0 {
+            len += 1;
+        }
+        if self.counterparty.is_some() {
+            len += 1;
+        }
+        if self.delay_period != 0 {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.connection.v1.ConnectionEnd", len)?;
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        if !self.versions.is_empty() {
+            struct_ser.serialize_field("versions", &self.versions)?;
+        }
+        if self.state != 0 {
+            let v = State::try_from(self.state).map_err(|_| {
+                serde::ser::Error::custom(format!("Invalid variant {}", self.state))
+            })?;
+            struct_ser.serialize_field("state", &v)?;
+        }
+        if let Some(v) = self.counterparty.as_ref() {
+            struct_ser.serialize_field("counterparty", v)?;
+        }
+        if self.delay_period != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "delayPeriod",
+                ToString::to_string(&self.delay_period).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ConnectionEnd {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "client_id",
+            "clientId",
+            "versions",
+            "state",
+            "counterparty",
+            "delay_period",
+            "delayPeriod",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientId,
+            Versions,
+            State,
+            Counterparty,
+            DelayPeriod,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            "versions" => Ok(GeneratedField::Versions),
+                            "state" => Ok(GeneratedField::State),
+                            "counterparty" => Ok(GeneratedField::Counterparty),
+                            "delayPeriod" | "delay_period" => Ok(GeneratedField::DelayPeriod),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ConnectionEnd;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.ConnectionEnd")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectionEnd, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut client_id__ = None;
+                let mut versions__ = None;
+                let mut state__ = None;
+                let mut counterparty__ = None;
+                let mut delay_period__ = 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::Versions => {
+                            if versions__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("versions"));
+                            }
+                            versions__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::State => {
+                            if state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("state"));
+                            }
+                            state__ = Some(map_.next_value::<State>()? as i32);
+                        }
+                        GeneratedField::Counterparty => {
+                            if counterparty__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("counterparty"));
+                            }
+                            counterparty__ = map_.next_value()?;
+                        }
+                        GeneratedField::DelayPeriod => {
+                            if delay_period__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("delayPeriod"));
+                            }
+                            delay_period__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(ConnectionEnd {
+                    client_id: client_id__.unwrap_or_default(),
+                    versions: versions__.unwrap_or_default(),
+                    state: state__.unwrap_or_default(),
+                    counterparty: counterparty__,
+                    delay_period: delay_period__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.ConnectionEnd",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for ConnectionPaths {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        if !self.paths.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.connection.v1.ConnectionPaths", len)?;
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        if !self.paths.is_empty() {
+            struct_ser.serialize_field("paths", &self.paths)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ConnectionPaths {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["client_id", "clientId", "paths"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientId,
+            Paths,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            "paths" => Ok(GeneratedField::Paths),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ConnectionPaths;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.ConnectionPaths")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectionPaths, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut client_id__ = None;
+                let mut paths__ = 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::Paths => {
+                            if paths__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("paths"));
+                            }
+                            paths__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(ConnectionPaths {
+                    client_id: client_id__.unwrap_or_default(),
+                    paths: paths__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.ConnectionPaths",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Counterparty {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        if !self.connection_id.is_empty() {
+            len += 1;
+        }
+        if self.prefix.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.connection.v1.Counterparty", len)?;
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        if !self.connection_id.is_empty() {
+            struct_ser.serialize_field("connectionId", &self.connection_id)?;
+        }
+        if let Some(v) = self.prefix.as_ref() {
+            struct_ser.serialize_field("prefix", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Counterparty {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "client_id",
+            "clientId",
+            "connection_id",
+            "connectionId",
+            "prefix",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientId,
+            ConnectionId,
+            Prefix,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
+                            "prefix" => Ok(GeneratedField::Prefix),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Counterparty;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.Counterparty")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Counterparty, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut client_id__ = None;
+                let mut connection_id__ = None;
+                let mut prefix__ = 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::ConnectionId => {
+                            if connection_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("connectionId"));
+                            }
+                            connection_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Prefix => {
+                            if prefix__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("prefix"));
+                            }
+                            prefix__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(Counterparty {
+                    client_id: client_id__.unwrap_or_default(),
+                    connection_id: connection_id__.unwrap_or_default(),
+                    prefix: prefix__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.Counterparty",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for GenesisState {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.connections.is_empty() {
+            len += 1;
+        }
+        if !self.client_connection_paths.is_empty() {
+            len += 1;
+        }
+        if self.next_connection_sequence != 0 {
+            len += 1;
+        }
+        if self.params.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.connection.v1.GenesisState", len)?;
+        if !self.connections.is_empty() {
+            struct_ser.serialize_field("connections", &self.connections)?;
+        }
+        if !self.client_connection_paths.is_empty() {
+            struct_ser.serialize_field("clientConnectionPaths", &self.client_connection_paths)?;
+        }
+        if self.next_connection_sequence != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "nextConnectionSequence",
+                ToString::to_string(&self.next_connection_sequence).as_str(),
+            )?;
+        }
+        if let Some(v) = self.params.as_ref() {
+            struct_ser.serialize_field("params", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for GenesisState {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "connections",
+            "client_connection_paths",
+            "clientConnectionPaths",
+            "next_connection_sequence",
+            "nextConnectionSequence",
+            "params",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Connections,
+            ClientConnectionPaths,
+            NextConnectionSequence,
+            Params,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "connections" => Ok(GeneratedField::Connections),
+                            "clientConnectionPaths" | "client_connection_paths" => {
+                                Ok(GeneratedField::ClientConnectionPaths)
+                            }
+                            "nextConnectionSequence" | "next_connection_sequence" => {
+                                Ok(GeneratedField::NextConnectionSequence)
+                            }
+                            "params" => Ok(GeneratedField::Params),
+                            _ => 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 std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.GenesisState")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GenesisState, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut connections__ = None;
+                let mut client_connection_paths__ = None;
+                let mut next_connection_sequence__ = None;
+                let mut params__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Connections => {
+                            if connections__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("connections"));
+                            }
+                            connections__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ClientConnectionPaths => {
+                            if client_connection_paths__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "clientConnectionPaths",
+                                ));
+                            }
+                            client_connection_paths__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::NextConnectionSequence => {
+                            if next_connection_sequence__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "nextConnectionSequence",
+                                ));
+                            }
+                            next_connection_sequence__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Params => {
+                            if params__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("params"));
+                            }
+                            params__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(GenesisState {
+                    connections: connections__.unwrap_or_default(),
+                    client_connection_paths: client_connection_paths__.unwrap_or_default(),
+                    next_connection_sequence: next_connection_sequence__.unwrap_or_default(),
+                    params: params__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.GenesisState",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for IdentifiedConnection {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.id.is_empty() {
+            len += 1;
+        }
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        if !self.versions.is_empty() {
+            len += 1;
+        }
+        if self.state != 0 {
+            len += 1;
+        }
+        if self.counterparty.is_some() {
+            len += 1;
+        }
+        if self.delay_period != 0 {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.connection.v1.IdentifiedConnection", len)?;
+        if !self.id.is_empty() {
+            struct_ser.serialize_field("id", &self.id)?;
+        }
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        if !self.versions.is_empty() {
+            struct_ser.serialize_field("versions", &self.versions)?;
+        }
+        if self.state != 0 {
+            let v = State::try_from(self.state).map_err(|_| {
+                serde::ser::Error::custom(format!("Invalid variant {}", self.state))
+            })?;
+            struct_ser.serialize_field("state", &v)?;
+        }
+        if let Some(v) = self.counterparty.as_ref() {
+            struct_ser.serialize_field("counterparty", v)?;
+        }
+        if self.delay_period != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "delayPeriod",
+                ToString::to_string(&self.delay_period).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for IdentifiedConnection {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "id",
+            "client_id",
+            "clientId",
+            "versions",
+            "state",
+            "counterparty",
+            "delay_period",
+            "delayPeriod",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Id,
+            ClientId,
+            Versions,
+            State,
+            Counterparty,
+            DelayPeriod,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "id" => Ok(GeneratedField::Id),
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            "versions" => Ok(GeneratedField::Versions),
+                            "state" => Ok(GeneratedField::State),
+                            "counterparty" => Ok(GeneratedField::Counterparty),
+                            "delayPeriod" | "delay_period" => Ok(GeneratedField::DelayPeriod),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = IdentifiedConnection;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.IdentifiedConnection")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<IdentifiedConnection, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut id__ = None;
+                let mut client_id__ = None;
+                let mut versions__ = None;
+                let mut state__ = None;
+                let mut counterparty__ = None;
+                let mut delay_period__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Id => {
+                            if id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("id"));
+                            }
+                            id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ClientId => {
+                            if client_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("clientId"));
+                            }
+                            client_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Versions => {
+                            if versions__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("versions"));
+                            }
+                            versions__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::State => {
+                            if state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("state"));
+                            }
+                            state__ = Some(map_.next_value::<State>()? as i32);
+                        }
+                        GeneratedField::Counterparty => {
+                            if counterparty__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("counterparty"));
+                            }
+                            counterparty__ = map_.next_value()?;
+                        }
+                        GeneratedField::DelayPeriod => {
+                            if delay_period__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("delayPeriod"));
+                            }
+                            delay_period__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(IdentifiedConnection {
+                    id: id__.unwrap_or_default(),
+                    client_id: client_id__.unwrap_or_default(),
+                    versions: versions__.unwrap_or_default(),
+                    state: state__.unwrap_or_default(),
+                    counterparty: counterparty__,
+                    delay_period: delay_period__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.IdentifiedConnection",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgConnectionOpenAck {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.connection_id.is_empty() {
+            len += 1;
+        }
+        if !self.counterparty_connection_id.is_empty() {
+            len += 1;
+        }
+        if self.version.is_some() {
+            len += 1;
+        }
+        if self.client_state.is_some() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        if !self.proof_try.is_empty() {
+            len += 1;
+        }
+        if !self.proof_client.is_empty() {
+            len += 1;
+        }
+        if !self.proof_consensus.is_empty() {
+            len += 1;
+        }
+        if self.consensus_height.is_some() {
+            len += 1;
+        }
+        if !self.signer.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.connection.v1.MsgConnectionOpenAck", len)?;
+        if !self.connection_id.is_empty() {
+            struct_ser.serialize_field("connectionId", &self.connection_id)?;
+        }
+        if !self.counterparty_connection_id.is_empty() {
+            struct_ser
+                .serialize_field("counterpartyConnectionId", &self.counterparty_connection_id)?;
+        }
+        if let Some(v) = self.version.as_ref() {
+            struct_ser.serialize_field("version", v)?;
+        }
+        if let Some(v) = self.client_state.as_ref() {
+            struct_ser.serialize_field("clientState", v)?;
+        }
+        if let Some(v) = self.proof_height.as_ref() {
+            struct_ser.serialize_field("proofHeight", v)?;
+        }
+        if !self.proof_try.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "proofTry",
+                pbjson::private::base64::encode(&self.proof_try).as_str(),
+            )?;
+        }
+        if !self.proof_client.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "proofClient",
+                pbjson::private::base64::encode(&self.proof_client).as_str(),
+            )?;
+        }
+        if !self.proof_consensus.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "proofConsensus",
+                pbjson::private::base64::encode(&self.proof_consensus).as_str(),
+            )?;
+        }
+        if let Some(v) = self.consensus_height.as_ref() {
+            struct_ser.serialize_field("consensusHeight", v)?;
+        }
+        if !self.signer.is_empty() {
+            struct_ser.serialize_field("signer", &self.signer)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgConnectionOpenAck {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "connection_id",
+            "connectionId",
+            "counterparty_connection_id",
+            "counterpartyConnectionId",
+            "version",
+            "client_state",
+            "clientState",
+            "proof_height",
+            "proofHeight",
+            "proof_try",
+            "proofTry",
+            "proof_client",
+            "proofClient",
+            "proof_consensus",
+            "proofConsensus",
+            "consensus_height",
+            "consensusHeight",
+            "signer",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ConnectionId,
+            CounterpartyConnectionId,
+            Version,
+            ClientState,
+            ProofHeight,
+            ProofTry,
+            ProofClient,
+            ProofConsensus,
+            ConsensusHeight,
+            Signer,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
+                            "counterpartyConnectionId" | "counterparty_connection_id" => {
+                                Ok(GeneratedField::CounterpartyConnectionId)
+                            }
+                            "version" => Ok(GeneratedField::Version),
+                            "clientState" | "client_state" => Ok(GeneratedField::ClientState),
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            "proofTry" | "proof_try" => Ok(GeneratedField::ProofTry),
+                            "proofClient" | "proof_client" => Ok(GeneratedField::ProofClient),
+                            "proofConsensus" | "proof_consensus" => {
+                                Ok(GeneratedField::ProofConsensus)
+                            }
+                            "consensusHeight" | "consensus_height" => {
+                                Ok(GeneratedField::ConsensusHeight)
+                            }
+                            "signer" => Ok(GeneratedField::Signer),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgConnectionOpenAck;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.MsgConnectionOpenAck")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgConnectionOpenAck, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut connection_id__ = None;
+                let mut counterparty_connection_id__ = None;
+                let mut version__ = None;
+                let mut client_state__ = None;
+                let mut proof_height__ = None;
+                let mut proof_try__ = None;
+                let mut proof_client__ = None;
+                let mut proof_consensus__ = None;
+                let mut consensus_height__ = None;
+                let mut signer__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ConnectionId => {
+                            if connection_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("connectionId"));
+                            }
+                            connection_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::CounterpartyConnectionId => {
+                            if counterparty_connection_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "counterpartyConnectionId",
+                                ));
+                            }
+                            counterparty_connection_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Version => {
+                            if version__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("version"));
+                            }
+                            version__ = map_.next_value()?;
+                        }
+                        GeneratedField::ClientState => {
+                            if client_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("clientState"));
+                            }
+                            client_state__ = map_.next_value()?;
+                        }
+                        GeneratedField::ProofHeight => {
+                            if proof_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofHeight"));
+                            }
+                            proof_height__ = map_.next_value()?;
+                        }
+                        GeneratedField::ProofTry => {
+                            if proof_try__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofTry"));
+                            }
+                            proof_try__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::ProofClient => {
+                            if proof_client__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofClient"));
+                            }
+                            proof_client__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::ProofConsensus => {
+                            if proof_consensus__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofConsensus"));
+                            }
+                            proof_consensus__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::ConsensusHeight => {
+                            if consensus_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("consensusHeight"));
+                            }
+                            consensus_height__ = map_.next_value()?;
+                        }
+                        GeneratedField::Signer => {
+                            if signer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signer"));
+                            }
+                            signer__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgConnectionOpenAck {
+                    connection_id: connection_id__.unwrap_or_default(),
+                    counterparty_connection_id: counterparty_connection_id__.unwrap_or_default(),
+                    version: version__,
+                    client_state: client_state__,
+                    proof_height: proof_height__,
+                    proof_try: proof_try__.unwrap_or_default(),
+                    proof_client: proof_client__.unwrap_or_default(),
+                    proof_consensus: proof_consensus__.unwrap_or_default(),
+                    consensus_height: consensus_height__,
+                    signer: signer__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.MsgConnectionOpenAck",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgConnectionOpenAckResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser = serializer
+            .serialize_struct("ibc.core.connection.v1.MsgConnectionOpenAckResponse", len)?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgConnectionOpenAckResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgConnectionOpenAckResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.MsgConnectionOpenAckResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgConnectionOpenAckResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(MsgConnectionOpenAckResponse {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.MsgConnectionOpenAckResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgConnectionOpenConfirm {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.connection_id.is_empty() {
+            len += 1;
+        }
+        if !self.proof_ack.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        if !self.signer.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.connection.v1.MsgConnectionOpenConfirm", len)?;
+        if !self.connection_id.is_empty() {
+            struct_ser.serialize_field("connectionId", &self.connection_id)?;
+        }
+        if !self.proof_ack.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "proofAck",
+                pbjson::private::base64::encode(&self.proof_ack).as_str(),
+            )?;
+        }
+        if let Some(v) = self.proof_height.as_ref() {
+            struct_ser.serialize_field("proofHeight", v)?;
+        }
+        if !self.signer.is_empty() {
+            struct_ser.serialize_field("signer", &self.signer)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgConnectionOpenConfirm {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "connection_id",
+            "connectionId",
+            "proof_ack",
+            "proofAck",
+            "proof_height",
+            "proofHeight",
+            "signer",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ConnectionId,
+            ProofAck,
+            ProofHeight,
+            Signer,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
+                            "proofAck" | "proof_ack" => Ok(GeneratedField::ProofAck),
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            "signer" => Ok(GeneratedField::Signer),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgConnectionOpenConfirm;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.MsgConnectionOpenConfirm")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgConnectionOpenConfirm, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut connection_id__ = None;
+                let mut proof_ack__ = None;
+                let mut proof_height__ = None;
+                let mut signer__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ConnectionId => {
+                            if connection_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("connectionId"));
+                            }
+                            connection_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ProofAck => {
+                            if proof_ack__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofAck"));
+                            }
+                            proof_ack__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::ProofHeight => {
+                            if proof_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofHeight"));
+                            }
+                            proof_height__ = map_.next_value()?;
+                        }
+                        GeneratedField::Signer => {
+                            if signer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signer"));
+                            }
+                            signer__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgConnectionOpenConfirm {
+                    connection_id: connection_id__.unwrap_or_default(),
+                    proof_ack: proof_ack__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                    signer: signer__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.MsgConnectionOpenConfirm",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgConnectionOpenConfirmResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser = serializer.serialize_struct(
+            "ibc.core.connection.v1.MsgConnectionOpenConfirmResponse",
+            len,
+        )?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgConnectionOpenConfirmResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgConnectionOpenConfirmResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter
+                    .write_str("struct ibc.core.connection.v1.MsgConnectionOpenConfirmResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgConnectionOpenConfirmResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(MsgConnectionOpenConfirmResponse {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.MsgConnectionOpenConfirmResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgConnectionOpenInit {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        if self.counterparty.is_some() {
+            len += 1;
+        }
+        if self.version.is_some() {
+            len += 1;
+        }
+        if self.delay_period != 0 {
+            len += 1;
+        }
+        if !self.signer.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.connection.v1.MsgConnectionOpenInit", len)?;
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        if let Some(v) = self.counterparty.as_ref() {
+            struct_ser.serialize_field("counterparty", v)?;
+        }
+        if let Some(v) = self.version.as_ref() {
+            struct_ser.serialize_field("version", v)?;
+        }
+        if self.delay_period != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "delayPeriod",
+                ToString::to_string(&self.delay_period).as_str(),
+            )?;
+        }
+        if !self.signer.is_empty() {
+            struct_ser.serialize_field("signer", &self.signer)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgConnectionOpenInit {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "client_id",
+            "clientId",
+            "counterparty",
+            "version",
+            "delay_period",
+            "delayPeriod",
+            "signer",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientId,
+            Counterparty,
+            Version,
+            DelayPeriod,
+            Signer,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            "counterparty" => Ok(GeneratedField::Counterparty),
+                            "version" => Ok(GeneratedField::Version),
+                            "delayPeriod" | "delay_period" => Ok(GeneratedField::DelayPeriod),
+                            "signer" => Ok(GeneratedField::Signer),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgConnectionOpenInit;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.MsgConnectionOpenInit")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgConnectionOpenInit, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut client_id__ = None;
+                let mut counterparty__ = None;
+                let mut version__ = None;
+                let mut delay_period__ = None;
+                let mut signer__ = 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::Counterparty => {
+                            if counterparty__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("counterparty"));
+                            }
+                            counterparty__ = map_.next_value()?;
+                        }
+                        GeneratedField::Version => {
+                            if version__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("version"));
+                            }
+                            version__ = map_.next_value()?;
+                        }
+                        GeneratedField::DelayPeriod => {
+                            if delay_period__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("delayPeriod"));
+                            }
+                            delay_period__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Signer => {
+                            if signer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signer"));
+                            }
+                            signer__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgConnectionOpenInit {
+                    client_id: client_id__.unwrap_or_default(),
+                    counterparty: counterparty__,
+                    version: version__,
+                    delay_period: delay_period__.unwrap_or_default(),
+                    signer: signer__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.MsgConnectionOpenInit",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgConnectionOpenInitResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser = serializer
+            .serialize_struct("ibc.core.connection.v1.MsgConnectionOpenInitResponse", len)?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgConnectionOpenInitResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgConnectionOpenInitResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.MsgConnectionOpenInitResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgConnectionOpenInitResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(MsgConnectionOpenInitResponse {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.MsgConnectionOpenInitResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgConnectionOpenTry {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        if !self.previous_connection_id.is_empty() {
+            len += 1;
+        }
+        if self.client_state.is_some() {
+            len += 1;
+        }
+        if self.counterparty.is_some() {
+            len += 1;
+        }
+        if self.delay_period != 0 {
+            len += 1;
+        }
+        if !self.counterparty_versions.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        if !self.proof_init.is_empty() {
+            len += 1;
+        }
+        if !self.proof_client.is_empty() {
+            len += 1;
+        }
+        if !self.proof_consensus.is_empty() {
+            len += 1;
+        }
+        if self.consensus_height.is_some() {
+            len += 1;
+        }
+        if !self.signer.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.connection.v1.MsgConnectionOpenTry", len)?;
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        if !self.previous_connection_id.is_empty() {
+            struct_ser.serialize_field("previousConnectionId", &self.previous_connection_id)?;
+        }
+        if let Some(v) = self.client_state.as_ref() {
+            struct_ser.serialize_field("clientState", v)?;
+        }
+        if let Some(v) = self.counterparty.as_ref() {
+            struct_ser.serialize_field("counterparty", v)?;
+        }
+        if self.delay_period != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "delayPeriod",
+                ToString::to_string(&self.delay_period).as_str(),
+            )?;
+        }
+        if !self.counterparty_versions.is_empty() {
+            struct_ser.serialize_field("counterpartyVersions", &self.counterparty_versions)?;
+        }
+        if let Some(v) = self.proof_height.as_ref() {
+            struct_ser.serialize_field("proofHeight", v)?;
+        }
+        if !self.proof_init.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "proofInit",
+                pbjson::private::base64::encode(&self.proof_init).as_str(),
+            )?;
+        }
+        if !self.proof_client.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "proofClient",
+                pbjson::private::base64::encode(&self.proof_client).as_str(),
+            )?;
+        }
+        if !self.proof_consensus.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "proofConsensus",
+                pbjson::private::base64::encode(&self.proof_consensus).as_str(),
+            )?;
+        }
+        if let Some(v) = self.consensus_height.as_ref() {
+            struct_ser.serialize_field("consensusHeight", v)?;
+        }
+        if !self.signer.is_empty() {
+            struct_ser.serialize_field("signer", &self.signer)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgConnectionOpenTry {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "client_id",
+            "clientId",
+            "previous_connection_id",
+            "previousConnectionId",
+            "client_state",
+            "clientState",
+            "counterparty",
+            "delay_period",
+            "delayPeriod",
+            "counterparty_versions",
+            "counterpartyVersions",
+            "proof_height",
+            "proofHeight",
+            "proof_init",
+            "proofInit",
+            "proof_client",
+            "proofClient",
+            "proof_consensus",
+            "proofConsensus",
+            "consensus_height",
+            "consensusHeight",
+            "signer",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientId,
+            PreviousConnectionId,
+            ClientState,
+            Counterparty,
+            DelayPeriod,
+            CounterpartyVersions,
+            ProofHeight,
+            ProofInit,
+            ProofClient,
+            ProofConsensus,
+            ConsensusHeight,
+            Signer,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            "previousConnectionId" | "previous_connection_id" => {
+                                Ok(GeneratedField::PreviousConnectionId)
+                            }
+                            "clientState" | "client_state" => Ok(GeneratedField::ClientState),
+                            "counterparty" => Ok(GeneratedField::Counterparty),
+                            "delayPeriod" | "delay_period" => Ok(GeneratedField::DelayPeriod),
+                            "counterpartyVersions" | "counterparty_versions" => {
+                                Ok(GeneratedField::CounterpartyVersions)
+                            }
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            "proofInit" | "proof_init" => Ok(GeneratedField::ProofInit),
+                            "proofClient" | "proof_client" => Ok(GeneratedField::ProofClient),
+                            "proofConsensus" | "proof_consensus" => {
+                                Ok(GeneratedField::ProofConsensus)
+                            }
+                            "consensusHeight" | "consensus_height" => {
+                                Ok(GeneratedField::ConsensusHeight)
+                            }
+                            "signer" => Ok(GeneratedField::Signer),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgConnectionOpenTry;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.MsgConnectionOpenTry")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgConnectionOpenTry, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut client_id__ = None;
+                let mut previous_connection_id__ = None;
+                let mut client_state__ = None;
+                let mut counterparty__ = None;
+                let mut delay_period__ = None;
+                let mut counterparty_versions__ = None;
+                let mut proof_height__ = None;
+                let mut proof_init__ = None;
+                let mut proof_client__ = None;
+                let mut proof_consensus__ = None;
+                let mut consensus_height__ = None;
+                let mut signer__ = 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::PreviousConnectionId => {
+                            if previous_connection_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "previousConnectionId",
+                                ));
+                            }
+                            previous_connection_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ClientState => {
+                            if client_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("clientState"));
+                            }
+                            client_state__ = map_.next_value()?;
+                        }
+                        GeneratedField::Counterparty => {
+                            if counterparty__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("counterparty"));
+                            }
+                            counterparty__ = map_.next_value()?;
+                        }
+                        GeneratedField::DelayPeriod => {
+                            if delay_period__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("delayPeriod"));
+                            }
+                            delay_period__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::CounterpartyVersions => {
+                            if counterparty_versions__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "counterpartyVersions",
+                                ));
+                            }
+                            counterparty_versions__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ProofHeight => {
+                            if proof_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofHeight"));
+                            }
+                            proof_height__ = map_.next_value()?;
+                        }
+                        GeneratedField::ProofInit => {
+                            if proof_init__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofInit"));
+                            }
+                            proof_init__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::ProofClient => {
+                            if proof_client__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofClient"));
+                            }
+                            proof_client__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::ProofConsensus => {
+                            if proof_consensus__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofConsensus"));
+                            }
+                            proof_consensus__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::ConsensusHeight => {
+                            if consensus_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("consensusHeight"));
+                            }
+                            consensus_height__ = map_.next_value()?;
+                        }
+                        GeneratedField::Signer => {
+                            if signer__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signer"));
+                            }
+                            signer__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgConnectionOpenTry {
+                    client_id: client_id__.unwrap_or_default(),
+                    previous_connection_id: previous_connection_id__.unwrap_or_default(),
+                    client_state: client_state__,
+                    counterparty: counterparty__,
+                    delay_period: delay_period__.unwrap_or_default(),
+                    counterparty_versions: counterparty_versions__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                    proof_init: proof_init__.unwrap_or_default(),
+                    proof_client: proof_client__.unwrap_or_default(),
+                    proof_consensus: proof_consensus__.unwrap_or_default(),
+                    consensus_height: consensus_height__,
+                    signer: signer__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.MsgConnectionOpenTry",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for MsgConnectionOpenTryResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser = serializer
+            .serialize_struct("ibc.core.connection.v1.MsgConnectionOpenTryResponse", len)?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for MsgConnectionOpenTryResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgConnectionOpenTryResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.MsgConnectionOpenTryResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<MsgConnectionOpenTryResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(MsgConnectionOpenTryResponse {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.MsgConnectionOpenTryResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Params {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.max_expected_time_per_block != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ibc.core.connection.v1.Params", len)?;
+        if self.max_expected_time_per_block != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "maxExpectedTimePerBlock",
+                ToString::to_string(&self.max_expected_time_per_block).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Params {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["max_expected_time_per_block", "maxExpectedTimePerBlock"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            MaxExpectedTimePerBlock,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "maxExpectedTimePerBlock" | "max_expected_time_per_block" => {
+                                Ok(GeneratedField::MaxExpectedTimePerBlock)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Params;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.Params")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Params, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut max_expected_time_per_block__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::MaxExpectedTimePerBlock => {
+                            if max_expected_time_per_block__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "maxExpectedTimePerBlock",
+                                ));
+                            }
+                            max_expected_time_per_block__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(Params {
+                    max_expected_time_per_block: max_expected_time_per_block__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("ibc.core.connection.v1.Params", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryClientConnectionsRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.core.connection.v1.QueryClientConnectionsRequest", len)?;
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryClientConnectionsRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["client_id", "clientId"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientId,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryClientConnectionsRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.QueryClientConnectionsRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryClientConnectionsRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                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(QueryClientConnectionsRequest {
+                    client_id: client_id__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.QueryClientConnectionsRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryClientConnectionsResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.connection_paths.is_empty() {
+            len += 1;
+        }
+        if !self.proof.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.core.connection.v1.QueryClientConnectionsResponse", len)?;
+        if !self.connection_paths.is_empty() {
+            struct_ser.serialize_field("connectionPaths", &self.connection_paths)?;
+        }
+        if !self.proof.is_empty() {
+            #[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)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryClientConnectionsResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "connection_paths",
+            "connectionPaths",
+            "proof",
+            "proof_height",
+            "proofHeight",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ConnectionPaths,
+            Proof,
+            ProofHeight,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "connectionPaths" | "connection_paths" => {
+                                Ok(GeneratedField::ConnectionPaths)
+                            }
+                            "proof" => Ok(GeneratedField::Proof),
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryClientConnectionsResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.QueryClientConnectionsResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryClientConnectionsResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut connection_paths__ = None;
+                let mut proof__ = None;
+                let mut proof_height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ConnectionPaths => {
+                            if connection_paths__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("connectionPaths"));
+                            }
+                            connection_paths__ = 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()?;
+                        }
+                    }
+                }
+                Ok(QueryClientConnectionsResponse {
+                    connection_paths: connection_paths__.unwrap_or_default(),
+                    proof: proof__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.QueryClientConnectionsResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryConnectionClientStateRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.connection_id.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.core.connection.v1.QueryConnectionClientStateRequest",
+            len,
+        )?;
+        if !self.connection_id.is_empty() {
+            struct_ser.serialize_field("connectionId", &self.connection_id)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryConnectionClientStateRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["connection_id", "connectionId"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ConnectionId,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryConnectionClientStateRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter
+                    .write_str("struct ibc.core.connection.v1.QueryConnectionClientStateRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryConnectionClientStateRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut connection_id__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ConnectionId => {
+                            if connection_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("connectionId"));
+                            }
+                            connection_id__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryConnectionClientStateRequest {
+                    connection_id: connection_id__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.QueryConnectionClientStateRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryConnectionClientStateResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.identified_client_state.is_some() {
+            len += 1;
+        }
+        if !self.proof.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.core.connection.v1.QueryConnectionClientStateResponse",
+            len,
+        )?;
+        if let Some(v) = self.identified_client_state.as_ref() {
+            struct_ser.serialize_field("identifiedClientState", v)?;
+        }
+        if !self.proof.is_empty() {
+            #[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)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryConnectionClientStateResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "identified_client_state",
+            "identifiedClientState",
+            "proof",
+            "proof_height",
+            "proofHeight",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            IdentifiedClientState,
+            Proof,
+            ProofHeight,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "identifiedClientState" | "identified_client_state" => {
+                                Ok(GeneratedField::IdentifiedClientState)
+                            }
+                            "proof" => Ok(GeneratedField::Proof),
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryConnectionClientStateResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter
+                    .write_str("struct ibc.core.connection.v1.QueryConnectionClientStateResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryConnectionClientStateResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut identified_client_state__ = None;
+                let mut proof__ = None;
+                let mut proof_height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::IdentifiedClientState => {
+                            if identified_client_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "identifiedClientState",
+                                ));
+                            }
+                            identified_client_state__ = 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()?;
+                        }
+                    }
+                }
+                Ok(QueryConnectionClientStateResponse {
+                    identified_client_state: identified_client_state__,
+                    proof: proof__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.QueryConnectionClientStateResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryConnectionConsensusStateRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.connection_id.is_empty() {
+            len += 1;
+        }
+        if self.revision_number != 0 {
+            len += 1;
+        }
+        if self.revision_height != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.core.connection.v1.QueryConnectionConsensusStateRequest",
+            len,
+        )?;
+        if !self.connection_id.is_empty() {
+            struct_ser.serialize_field("connectionId", &self.connection_id)?;
+        }
+        if self.revision_number != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "revisionNumber",
+                ToString::to_string(&self.revision_number).as_str(),
+            )?;
+        }
+        if self.revision_height != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "revisionHeight",
+                ToString::to_string(&self.revision_height).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryConnectionConsensusStateRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "connection_id",
+            "connectionId",
+            "revision_number",
+            "revisionNumber",
+            "revision_height",
+            "revisionHeight",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ConnectionId,
+            RevisionNumber,
+            RevisionHeight,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
+                            "revisionNumber" | "revision_number" => {
+                                Ok(GeneratedField::RevisionNumber)
+                            }
+                            "revisionHeight" | "revision_height" => {
+                                Ok(GeneratedField::RevisionHeight)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryConnectionConsensusStateRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter
+                    .write_str("struct ibc.core.connection.v1.QueryConnectionConsensusStateRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryConnectionConsensusStateRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut connection_id__ = None;
+                let mut revision_number__ = None;
+                let mut revision_height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ConnectionId => {
+                            if connection_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("connectionId"));
+                            }
+                            connection_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::RevisionNumber => {
+                            if revision_number__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("revisionNumber"));
+                            }
+                            revision_number__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::RevisionHeight => {
+                            if revision_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("revisionHeight"));
+                            }
+                            revision_height__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(QueryConnectionConsensusStateRequest {
+                    connection_id: connection_id__.unwrap_or_default(),
+                    revision_number: revision_number__.unwrap_or_default(),
+                    revision_height: revision_height__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.QueryConnectionConsensusStateRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryConnectionConsensusStateResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.consensus_state.is_some() {
+            len += 1;
+        }
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        if !self.proof.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.core.connection.v1.QueryConnectionConsensusStateResponse",
+            len,
+        )?;
+        if let Some(v) = self.consensus_state.as_ref() {
+            struct_ser.serialize_field("consensusState", v)?;
+        }
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        if !self.proof.is_empty() {
+            #[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)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryConnectionConsensusStateResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "consensus_state",
+            "consensusState",
+            "client_id",
+            "clientId",
+            "proof",
+            "proof_height",
+            "proofHeight",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ConsensusState,
+            ClientId,
+            Proof,
+            ProofHeight,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "consensusState" | "consensus_state" => {
+                                Ok(GeneratedField::ConsensusState)
+                            }
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            "proof" => Ok(GeneratedField::Proof),
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryConnectionConsensusStateResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str(
+                    "struct ibc.core.connection.v1.QueryConnectionConsensusStateResponse",
+                )
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryConnectionConsensusStateResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut consensus_state__ = None;
+                let mut client_id__ = None;
+                let mut proof__ = None;
+                let mut proof_height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ConsensusState => {
+                            if consensus_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("consensusState"));
+                            }
+                            consensus_state__ = map_.next_value()?;
+                        }
+                        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()?;
+                        }
+                    }
+                }
+                Ok(QueryConnectionConsensusStateResponse {
+                    consensus_state: consensus_state__,
+                    client_id: client_id__.unwrap_or_default(),
+                    proof: proof__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.QueryConnectionConsensusStateResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryConnectionParamsRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser = serializer
+            .serialize_struct("ibc.core.connection.v1.QueryConnectionParamsRequest", len)?;
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryConnectionParamsRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {}
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryConnectionParamsRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.QueryConnectionParamsRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryConnectionParamsRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(QueryConnectionParamsRequest {})
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.QueryConnectionParamsRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryConnectionParamsResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.params.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.core.connection.v1.QueryConnectionParamsResponse", len)?;
+        if let Some(v) = self.params.as_ref() {
+            struct_ser.serialize_field("params", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryConnectionParamsResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["params"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Params,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "params" => Ok(GeneratedField::Params),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryConnectionParamsResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.QueryConnectionParamsResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryConnectionParamsResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut params__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Params => {
+                            if params__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("params"));
+                            }
+                            params__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryConnectionParamsResponse { params: params__ })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.QueryConnectionParamsResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryConnectionRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.connection_id.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.connection.v1.QueryConnectionRequest", len)?;
+        if !self.connection_id.is_empty() {
+            struct_ser.serialize_field("connectionId", &self.connection_id)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryConnectionRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["connection_id", "connectionId"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ConnectionId,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryConnectionRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.QueryConnectionRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryConnectionRequest, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut connection_id__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ConnectionId => {
+                            if connection_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("connectionId"));
+                            }
+                            connection_id__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(QueryConnectionRequest {
+                    connection_id: connection_id__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.QueryConnectionRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryConnectionResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.connection.is_some() {
+            len += 1;
+        }
+        if !self.proof.is_empty() {
+            len += 1;
+        }
+        if self.proof_height.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.connection.v1.QueryConnectionResponse", len)?;
+        if let Some(v) = self.connection.as_ref() {
+            struct_ser.serialize_field("connection", v)?;
+        }
+        if !self.proof.is_empty() {
+            #[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)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryConnectionResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["connection", "proof", "proof_height", "proofHeight"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Connection,
+            Proof,
+            ProofHeight,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "connection" => Ok(GeneratedField::Connection),
+                            "proof" => Ok(GeneratedField::Proof),
+                            "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryConnectionResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.QueryConnectionResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryConnectionResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut connection__ = None;
+                let mut proof__ = None;
+                let mut proof_height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Connection => {
+                            if connection__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("connection"));
+                            }
+                            connection__ = 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()?;
+                        }
+                    }
+                }
+                Ok(QueryConnectionResponse {
+                    connection: connection__,
+                    proof: proof__.unwrap_or_default(),
+                    proof_height: proof_height__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.QueryConnectionResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryConnectionsRequest {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.pagination.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.connection.v1.QueryConnectionsRequest", len)?;
+        if let Some(v) = self.pagination.as_ref() {
+            struct_ser.serialize_field("pagination", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryConnectionsRequest {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["pagination"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Pagination,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    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 = QueryConnectionsRequest;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.QueryConnectionsRequest")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryConnectionsRequest, V::Error>
+            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(QueryConnectionsRequest {
+                    pagination: pagination__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.QueryConnectionsRequest",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for QueryConnectionsResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.connections.is_empty() {
+            len += 1;
+        }
+        if self.pagination.is_some() {
+            len += 1;
+        }
+        if self.height.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.core.connection.v1.QueryConnectionsResponse", len)?;
+        if !self.connections.is_empty() {
+            struct_ser.serialize_field("connections", &self.connections)?;
+        }
+        if let Some(v) = self.pagination.as_ref() {
+            struct_ser.serialize_field("pagination", v)?;
+        }
+        if let Some(v) = self.height.as_ref() {
+            struct_ser.serialize_field("height", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for QueryConnectionsResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["connections", "pagination", "height"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Connections,
+            Pagination,
+            Height,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "connections" => Ok(GeneratedField::Connections),
+                            "pagination" => Ok(GeneratedField::Pagination),
+                            "height" => Ok(GeneratedField::Height),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = QueryConnectionsResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.QueryConnectionsResponse")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<QueryConnectionsResponse, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut connections__ = None;
+                let mut pagination__ = None;
+                let mut height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Connections => {
+                            if connections__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("connections"));
+                            }
+                            connections__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Pagination => {
+                            if pagination__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("pagination"));
+                            }
+                            pagination__ = map_.next_value()?;
+                        }
+                        GeneratedField::Height => {
+                            if height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("height"));
+                            }
+                            height__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(QueryConnectionsResponse {
+                    connections: connections__.unwrap_or_default(),
+                    pagination: pagination__,
+                    height: height__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.core.connection.v1.QueryConnectionsResponse",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for State {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::UninitializedUnspecified => "STATE_UNINITIALIZED_UNSPECIFIED",
+            Self::Init => "STATE_INIT",
+            Self::Tryopen => "STATE_TRYOPEN",
+            Self::Open => "STATE_OPEN",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for State {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "STATE_UNINITIALIZED_UNSPECIFIED",
+            "STATE_INIT",
+            "STATE_TRYOPEN",
+            "STATE_OPEN",
+        ];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = State;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                i32::try_from(v)
+                    .ok()
+                    .and_then(|x| x.try_into().ok())
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                i32::try_from(v)
+                    .ok()
+                    .and_then(|x| x.try_into().ok())
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "STATE_UNINITIALIZED_UNSPECIFIED" => Ok(State::UninitializedUnspecified),
+                    "STATE_INIT" => Ok(State::Init),
+                    "STATE_TRYOPEN" => Ok(State::Tryopen),
+                    "STATE_OPEN" => Ok(State::Open),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Version {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.identifier.is_empty() {
+            len += 1;
+        }
+        if !self.features.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ibc.core.connection.v1.Version", len)?;
+        if !self.identifier.is_empty() {
+            struct_ser.serialize_field("identifier", &self.identifier)?;
+        }
+        if !self.features.is_empty() {
+            struct_ser.serialize_field("features", &self.features)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Version {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["identifier", "features"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Identifier,
+            Features,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "identifier" => Ok(GeneratedField::Identifier),
+                            "features" => Ok(GeneratedField::Features),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Version;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.connection.v1.Version")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Version, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut identifier__ = None;
+                let mut features__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Identifier => {
+                            if identifier__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("identifier"));
+                            }
+                            identifier__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Features => {
+                            if features__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("features"));
+                            }
+                            features__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(Version {
+                    identifier: identifier__.unwrap_or_default(),
+                    features: features__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("ibc.core.connection.v1.Version", FIELDS, GeneratedVisitor)
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.connection.v1.tonic.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.connection.v1.tonic.rs
new file mode 100644
index 00000000..fb5181d3
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.connection.v1.tonic.rs
@@ -0,0 +1,1093 @@
+// @generated
+/// Generated client implementations.
+#[cfg(feature = "grpc")]
+pub mod query_client {
+    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
+    use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
+    #[derive(Debug, Clone)]
+    pub struct QueryClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    #[cfg(feature = "grpc-transport")]
+    impl QueryClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> QueryClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> QueryClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
+                Into<StdError> + Send + Sync,
+        {
+            QueryClient::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
+        }
+        pub async fn connection(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryConnectionRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryConnectionResponse>, 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.connection.v1.Query/Connection");
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.connection.v1.Query",
+                "Connection",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn connections(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryConnectionsRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryConnectionsResponse>, 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.connection.v1.Query/Connections");
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.connection.v1.Query",
+                "Connections",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn client_connections(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryClientConnectionsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryClientConnectionsResponse>,
+            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.connection.v1.Query/ClientConnections",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.connection.v1.Query",
+                "ClientConnections",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn connection_client_state(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryConnectionClientStateRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryConnectionClientStateResponse>,
+            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.connection.v1.Query/ConnectionClientState",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.connection.v1.Query",
+                "ConnectionClientState",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn connection_consensus_state(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryConnectionConsensusStateRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryConnectionConsensusStateResponse>,
+            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.connection.v1.Query/ConnectionConsensusState",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.connection.v1.Query",
+                "ConnectionConsensusState",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn connection_params(
+            &mut self,
+            request: impl tonic::IntoRequest<super::QueryConnectionParamsRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryConnectionParamsResponse>, 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.connection.v1.Query/ConnectionParams",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.connection.v1.Query",
+                "ConnectionParams",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+#[cfg(feature = "grpc")]
+pub mod query_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 QueryServer.
+    #[async_trait]
+    pub trait Query: Send + Sync + 'static {
+        async fn connection(
+            &self,
+            request: tonic::Request<super::QueryConnectionRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryConnectionResponse>, tonic::Status>;
+        async fn connections(
+            &self,
+            request: tonic::Request<super::QueryConnectionsRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryConnectionsResponse>, tonic::Status>;
+        async fn client_connections(
+            &self,
+            request: tonic::Request<super::QueryClientConnectionsRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryClientConnectionsResponse>,
+            tonic::Status,
+        >;
+        async fn connection_client_state(
+            &self,
+            request: tonic::Request<super::QueryConnectionClientStateRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryConnectionClientStateResponse>,
+            tonic::Status,
+        >;
+        async fn connection_consensus_state(
+            &self,
+            request: tonic::Request<super::QueryConnectionConsensusStateRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::QueryConnectionConsensusStateResponse>,
+            tonic::Status,
+        >;
+        async fn connection_params(
+            &self,
+            request: tonic::Request<super::QueryConnectionParamsRequest>,
+        ) -> std::result::Result<tonic::Response<super::QueryConnectionParamsResponse>, tonic::Status>;
+    }
+    #[derive(Debug)]
+    pub struct QueryServer<T: Query> {
+        inner: _Inner<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    struct _Inner<T>(Arc<T>);
+    impl<T: Query> QueryServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            let inner = _Inner(inner);
+            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<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
+        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<T, B> tonic::codegen::Service<http::Request<B>> for QueryServer<T>
+    where
+        T: Query,
+        B: Body + Send + 'static,
+        B::Error: Into<StdError> + Send + 'static,
+    {
+        type Response = http::Response<tonic::body::BoxBody>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            let inner = self.inner.clone();
+            match req.uri().path() {
+                "/ibc.core.connection.v1.Query/Connection" => {
+                    #[allow(non_camel_case_types)]
+                    struct ConnectionSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryConnectionRequest> for ConnectionSvc<T> {
+                        type Response = super::QueryConnectionResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryConnectionRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).connection(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 = ConnectionSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.connection.v1.Query/Connections" => {
+                    #[allow(non_camel_case_types)]
+                    struct ConnectionsSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryConnectionsRequest> for ConnectionsSvc<T> {
+                        type Response = super::QueryConnectionsResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryConnectionsRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).connections(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 = ConnectionsSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.connection.v1.Query/ClientConnections" => {
+                    #[allow(non_camel_case_types)]
+                    struct ClientConnectionsSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryClientConnectionsRequest>
+                        for ClientConnectionsSvc<T>
+                    {
+                        type Response = super::QueryClientConnectionsResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryClientConnectionsRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).client_connections(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 = ClientConnectionsSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.connection.v1.Query/ConnectionClientState" => {
+                    #[allow(non_camel_case_types)]
+                    struct ConnectionClientStateSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query>
+                        tonic::server::UnaryService<super::QueryConnectionClientStateRequest>
+                        for ConnectionClientStateSvc<T>
+                    {
+                        type Response = super::QueryConnectionClientStateResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryConnectionClientStateRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut =
+                                async move { (*inner).connection_client_state(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 = ConnectionClientStateSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.connection.v1.Query/ConnectionConsensusState" => {
+                    #[allow(non_camel_case_types)]
+                    struct ConnectionConsensusStateSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query>
+                        tonic::server::UnaryService<super::QueryConnectionConsensusStateRequest>
+                        for ConnectionConsensusStateSvc<T>
+                    {
+                        type Response = super::QueryConnectionConsensusStateResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryConnectionConsensusStateRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut =
+                                async move { (*inner).connection_consensus_state(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 = ConnectionConsensusStateSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.connection.v1.Query/ConnectionParams" => {
+                    #[allow(non_camel_case_types)]
+                    struct ConnectionParamsSvc<T: Query>(pub Arc<T>);
+                    impl<T: Query> tonic::server::UnaryService<super::QueryConnectionParamsRequest>
+                        for ConnectionParamsSvc<T>
+                    {
+                        type Response = super::QueryConnectionParamsResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::QueryConnectionParamsRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).connection_params(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 = ConnectionParamsSvc(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", "12")
+                        .header("content-type", "application/grpc")
+                        .body(empty_body())
+                        .unwrap())
+                }),
+            }
+        }
+    }
+    impl<T: Query> Clone for QueryServer<T> {
+        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<T: Query> Clone for _Inner<T> {
+        fn clone(&self) -> Self {
+            Self(Arc::clone(&self.0))
+        }
+    }
+    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "{:?}", self.0)
+        }
+    }
+    impl<T: Query> tonic::server::NamedService for QueryServer<T> {
+        const NAME: &'static str = "ibc.core.connection.v1.Query";
+    }
+}
+/// Generated client implementations.
+#[cfg(feature = "grpc")]
+pub mod msg_client {
+    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
+    use tonic::codegen::http::Uri;
+    use tonic::codegen::*;
+    #[derive(Debug, Clone)]
+    pub struct MsgClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    #[cfg(feature = "grpc-transport")]
+    impl MsgClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> MsgClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(inner: T, interceptor: F) -> MsgClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
+                Into<StdError> + Send + Sync,
+        {
+            MsgClient::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
+        }
+        pub async fn connection_open_init(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgConnectionOpenInit>,
+        ) -> std::result::Result<tonic::Response<super::MsgConnectionOpenInitResponse>, 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.connection.v1.Msg/ConnectionOpenInit",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.connection.v1.Msg",
+                "ConnectionOpenInit",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn connection_open_try(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgConnectionOpenTry>,
+        ) -> std::result::Result<tonic::Response<super::MsgConnectionOpenTryResponse>, 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.connection.v1.Msg/ConnectionOpenTry",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.connection.v1.Msg",
+                "ConnectionOpenTry",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn connection_open_ack(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgConnectionOpenAck>,
+        ) -> std::result::Result<tonic::Response<super::MsgConnectionOpenAckResponse>, 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.connection.v1.Msg/ConnectionOpenAck",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.connection.v1.Msg",
+                "ConnectionOpenAck",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn connection_open_confirm(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgConnectionOpenConfirm>,
+        ) -> std::result::Result<
+            tonic::Response<super::MsgConnectionOpenConfirmResponse>,
+            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.connection.v1.Msg/ConnectionOpenConfirm",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut().insert(GrpcMethod::new(
+                "ibc.core.connection.v1.Msg",
+                "ConnectionOpenConfirm",
+            ));
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+#[cfg(feature = "grpc")]
+pub mod msg_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 MsgServer.
+    #[async_trait]
+    pub trait Msg: Send + Sync + 'static {
+        async fn connection_open_init(
+            &self,
+            request: tonic::Request<super::MsgConnectionOpenInit>,
+        ) -> std::result::Result<tonic::Response<super::MsgConnectionOpenInitResponse>, tonic::Status>;
+        async fn connection_open_try(
+            &self,
+            request: tonic::Request<super::MsgConnectionOpenTry>,
+        ) -> std::result::Result<tonic::Response<super::MsgConnectionOpenTryResponse>, tonic::Status>;
+        async fn connection_open_ack(
+            &self,
+            request: tonic::Request<super::MsgConnectionOpenAck>,
+        ) -> std::result::Result<tonic::Response<super::MsgConnectionOpenAckResponse>, tonic::Status>;
+        async fn connection_open_confirm(
+            &self,
+            request: tonic::Request<super::MsgConnectionOpenConfirm>,
+        ) -> std::result::Result<
+            tonic::Response<super::MsgConnectionOpenConfirmResponse>,
+            tonic::Status,
+        >;
+    }
+    #[derive(Debug)]
+    pub struct MsgServer<T: Msg> {
+        inner: _Inner<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    struct _Inner<T>(Arc<T>);
+    impl<T: Msg> MsgServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            let inner = _Inner(inner);
+            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<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
+        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<T, B> tonic::codegen::Service<http::Request<B>> for MsgServer<T>
+    where
+        T: Msg,
+        B: Body + Send + 'static,
+        B::Error: Into<StdError> + Send + 'static,
+    {
+        type Response = http::Response<tonic::body::BoxBody>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            let inner = self.inner.clone();
+            match req.uri().path() {
+                "/ibc.core.connection.v1.Msg/ConnectionOpenInit" => {
+                    #[allow(non_camel_case_types)]
+                    struct ConnectionOpenInitSvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgConnectionOpenInit>
+                        for ConnectionOpenInitSvc<T>
+                    {
+                        type Response = super::MsgConnectionOpenInitResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgConnectionOpenInit>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).connection_open_init(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 = ConnectionOpenInitSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.connection.v1.Msg/ConnectionOpenTry" => {
+                    #[allow(non_camel_case_types)]
+                    struct ConnectionOpenTrySvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgConnectionOpenTry> for ConnectionOpenTrySvc<T> {
+                        type Response = super::MsgConnectionOpenTryResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgConnectionOpenTry>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).connection_open_try(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 = ConnectionOpenTrySvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.connection.v1.Msg/ConnectionOpenAck" => {
+                    #[allow(non_camel_case_types)]
+                    struct ConnectionOpenAckSvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgConnectionOpenAck> for ConnectionOpenAckSvc<T> {
+                        type Response = super::MsgConnectionOpenAckResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgConnectionOpenAck>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move { (*inner).connection_open_ack(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 = ConnectionOpenAckSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/ibc.core.connection.v1.Msg/ConnectionOpenConfirm" => {
+                    #[allow(non_camel_case_types)]
+                    struct ConnectionOpenConfirmSvc<T: Msg>(pub Arc<T>);
+                    impl<T: Msg> tonic::server::UnaryService<super::MsgConnectionOpenConfirm>
+                        for ConnectionOpenConfirmSvc<T>
+                    {
+                        type Response = super::MsgConnectionOpenConfirmResponse;
+                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::MsgConnectionOpenConfirm>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut =
+                                async move { (*inner).connection_open_confirm(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 = ConnectionOpenConfirmSvc(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", "12")
+                        .header("content-type", "application/grpc")
+                        .body(empty_body())
+                        .unwrap())
+                }),
+            }
+        }
+    }
+    impl<T: Msg> Clone for MsgServer<T> {
+        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<T: Msg> Clone for _Inner<T> {
+        fn clone(&self) -> Self {
+            Self(Arc::clone(&self.0))
+        }
+    }
+    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "{:?}", self.0)
+        }
+    }
+    impl<T: Msg> tonic::server::NamedService for MsgServer<T> {
+        const NAME: &'static str = "ibc.core.connection.v1.Msg";
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.types.v1.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.types.v1.rs
index 0b2718c5..0f822650 100644
--- a/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.types.v1.rs
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.types.v1.rs
@@ -1,4 +1,4 @@
-// This file is @generated by prost-build.
+// @generated
 /// GenesisState defines the ibc module's genesis state.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -13,13 +13,5 @@ pub struct GenesisState {
     #[prost(message, optional, tag = "3")]
     pub channel_genesis: ::core::option::Option<super::super::channel::v1::GenesisState>,
 }
-impl ::prost::Name for GenesisState {
-    const NAME: &'static str = "GenesisState";
-    const PACKAGE: &'static str = "ibc.core.types.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.core.types.v1.GenesisState".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.core.types.v1.GenesisState".into()
-    }
-}
+include!("ibc.core.types.v1.serde.rs");
+// @@protoc_insertion_point(module)
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.types.v1.serde.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.types.v1.serde.rs
new file mode 100644
index 00000000..97d30547
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.core.types.v1.serde.rs
@@ -0,0 +1,139 @@
+// @generated
+#[cfg(feature = "serde")]
+impl serde::Serialize for GenesisState {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.client_genesis.is_some() {
+            len += 1;
+        }
+        if self.connection_genesis.is_some() {
+            len += 1;
+        }
+        if self.channel_genesis.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ibc.core.types.v1.GenesisState", len)?;
+        if let Some(v) = self.client_genesis.as_ref() {
+            struct_ser.serialize_field("clientGenesis", v)?;
+        }
+        if let Some(v) = self.connection_genesis.as_ref() {
+            struct_ser.serialize_field("connectionGenesis", v)?;
+        }
+        if let Some(v) = self.channel_genesis.as_ref() {
+            struct_ser.serialize_field("channelGenesis", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for GenesisState {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "client_genesis",
+            "clientGenesis",
+            "connection_genesis",
+            "connectionGenesis",
+            "channel_genesis",
+            "channelGenesis",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientGenesis,
+            ConnectionGenesis,
+            ChannelGenesis,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientGenesis" | "client_genesis" => Ok(GeneratedField::ClientGenesis),
+                            "connectionGenesis" | "connection_genesis" => {
+                                Ok(GeneratedField::ConnectionGenesis)
+                            }
+                            "channelGenesis" | "channel_genesis" => {
+                                Ok(GeneratedField::ChannelGenesis)
+                            }
+                            _ => 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 std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.core.types.v1.GenesisState")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GenesisState, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut client_genesis__ = None;
+                let mut connection_genesis__ = None;
+                let mut channel_genesis__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ClientGenesis => {
+                            if client_genesis__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("clientGenesis"));
+                            }
+                            client_genesis__ = map_.next_value()?;
+                        }
+                        GeneratedField::ConnectionGenesis => {
+                            if connection_genesis__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("connectionGenesis"));
+                            }
+                            connection_genesis__ = map_.next_value()?;
+                        }
+                        GeneratedField::ChannelGenesis => {
+                            if channel_genesis__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channelGenesis"));
+                            }
+                            channel_genesis__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(GenesisState {
+                    client_genesis: client_genesis__,
+                    connection_genesis: connection_genesis__,
+                    channel_genesis: channel_genesis__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("ibc.core.types.v1.GenesisState", FIELDS, GeneratedVisitor)
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.localhost.v1.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.localhost.v1.rs
index e5413e37..69702480 100644
--- a/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.localhost.v1.rs
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.localhost.v1.rs
@@ -1,4 +1,4 @@
-// This file is @generated by prost-build.
+// @generated
 /// ClientState defines a loopback (localhost) client. It requires (read-only)
 /// access to keys outside the client prefix.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -11,13 +11,5 @@ pub struct ClientState {
     #[prost(message, optional, tag = "2")]
     pub height: ::core::option::Option<super::super::super::core::client::v1::Height>,
 }
-impl ::prost::Name for ClientState {
-    const NAME: &'static str = "ClientState";
-    const PACKAGE: &'static str = "ibc.lightclients.localhost.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.localhost.v1.ClientState".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.localhost.v1.ClientState".into()
-    }
-}
+include!("ibc.lightclients.localhost.v1.serde.rs");
+// @@protoc_insertion_point(module)
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.localhost.v1.serde.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.localhost.v1.serde.rs
new file mode 100644
index 00000000..6cfcf46c
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.localhost.v1.serde.rs
@@ -0,0 +1,117 @@
+// @generated
+#[cfg(feature = "serde")]
+impl serde::Serialize for ClientState {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.chain_id.is_empty() {
+            len += 1;
+        }
+        if self.height.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.localhost.v1.ClientState", len)?;
+        if !self.chain_id.is_empty() {
+            struct_ser.serialize_field("chainId", &self.chain_id)?;
+        }
+        if let Some(v) = self.height.as_ref() {
+            struct_ser.serialize_field("height", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ClientState {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["chain_id", "chainId", "height"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ChainId,
+            Height,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "chainId" | "chain_id" => Ok(GeneratedField::ChainId),
+                            "height" => Ok(GeneratedField::Height),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ClientState;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.localhost.v1.ClientState")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClientState, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut chain_id__ = None;
+                let mut height__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ChainId => {
+                            if chain_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("chainId"));
+                            }
+                            chain_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Height => {
+                            if height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("height"));
+                            }
+                            height__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(ClientState {
+                    chain_id: chain_id__.unwrap_or_default(),
+                    height: height__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.localhost.v1.ClientState",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.solomachine.v1.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.solomachine.v1.rs
index 4c3e232e..e6a41f85 100644
--- a/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.solomachine.v1.rs
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.solomachine.v1.rs
@@ -1,4 +1,4 @@
-// This file is @generated by prost-build.
+// @generated
 /// ClientState defines a solo machine client that tracks the current consensus
 /// state and if the client is frozen.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -17,16 +17,6 @@ pub struct ClientState {
     #[prost(bool, tag = "4")]
     pub allow_update_after_proposal: bool,
 }
-impl ::prost::Name for ClientState {
-    const NAME: &'static str = "ClientState";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v1.ClientState".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v1.ClientState".into()
-    }
-}
 /// ConsensusState defines a solo machine consensus state. The sequence of a
 /// consensus state is contained in the "height" key used in storing the
 /// consensus state.
@@ -44,16 +34,6 @@ pub struct ConsensusState {
     #[prost(uint64, tag = "3")]
     pub timestamp: u64,
 }
-impl ::prost::Name for ConsensusState {
-    const NAME: &'static str = "ConsensusState";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v1.ConsensusState".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v1.ConsensusState".into()
-    }
-}
 /// Header defines a solo machine consensus header
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -70,16 +50,6 @@ pub struct Header {
     #[prost(string, tag = "5")]
     pub new_diversifier: ::prost::alloc::string::String,
 }
-impl ::prost::Name for Header {
-    const NAME: &'static str = "Header";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v1.Header".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v1.Header".into()
-    }
-}
 /// Misbehaviour defines misbehaviour for a solo machine which consists
 /// of a sequence and two signatures over different messages at that sequence.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -94,16 +64,6 @@ pub struct Misbehaviour {
     #[prost(message, optional, tag = "4")]
     pub signature_two: ::core::option::Option<SignatureAndData>,
 }
-impl ::prost::Name for Misbehaviour {
-    const NAME: &'static str = "Misbehaviour";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v1.Misbehaviour".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v1.Misbehaviour".into()
-    }
-}
 /// SignatureAndData contains a signature and the data signed over to create that
 /// signature.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -118,16 +78,6 @@ pub struct SignatureAndData {
     #[prost(uint64, tag = "4")]
     pub timestamp: u64,
 }
-impl ::prost::Name for SignatureAndData {
-    const NAME: &'static str = "SignatureAndData";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v1.SignatureAndData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v1.SignatureAndData".into()
-    }
-}
 /// TimestampedSignatureData contains the signature data and the timestamp of the
 /// signature.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -138,16 +88,6 @@ pub struct TimestampedSignatureData {
     #[prost(uint64, tag = "2")]
     pub timestamp: u64,
 }
-impl ::prost::Name for TimestampedSignatureData {
-    const NAME: &'static str = "TimestampedSignatureData";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v1.TimestampedSignatureData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v1.TimestampedSignatureData".into()
-    }
-}
 /// SignBytes defines the signed bytes used for signature verification.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -165,16 +105,6 @@ pub struct SignBytes {
     #[prost(bytes = "vec", tag = "5")]
     pub data: ::prost::alloc::vec::Vec<u8>,
 }
-impl ::prost::Name for SignBytes {
-    const NAME: &'static str = "SignBytes";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v1.SignBytes".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v1.SignBytes".into()
-    }
-}
 /// HeaderData returns the SignBytes data for update verification.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -186,16 +116,6 @@ pub struct HeaderData {
     #[prost(string, tag = "2")]
     pub new_diversifier: ::prost::alloc::string::String,
 }
-impl ::prost::Name for HeaderData {
-    const NAME: &'static str = "HeaderData";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v1.HeaderData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v1.HeaderData".into()
-    }
-}
 /// ClientStateData returns the SignBytes data for client state verification.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -205,16 +125,6 @@ pub struct ClientStateData {
     #[prost(message, optional, tag = "2")]
     pub client_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
 }
-impl ::prost::Name for ClientStateData {
-    const NAME: &'static str = "ClientStateData";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v1.ClientStateData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v1.ClientStateData".into()
-    }
-}
 /// ConsensusStateData returns the SignBytes data for consensus state
 /// verification.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -225,16 +135,6 @@ pub struct ConsensusStateData {
     #[prost(message, optional, tag = "2")]
     pub consensus_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
 }
-impl ::prost::Name for ConsensusStateData {
-    const NAME: &'static str = "ConsensusStateData";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v1.ConsensusStateData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v1.ConsensusStateData".into()
-    }
-}
 /// ConnectionStateData returns the SignBytes data for connection state
 /// verification.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -246,16 +146,6 @@ pub struct ConnectionStateData {
     pub connection:
         ::core::option::Option<super::super::super::core::connection::v1::ConnectionEnd>,
 }
-impl ::prost::Name for ConnectionStateData {
-    const NAME: &'static str = "ConnectionStateData";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v1.ConnectionStateData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v1.ConnectionStateData".into()
-    }
-}
 /// ChannelStateData returns the SignBytes data for channel state
 /// verification.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -266,16 +156,6 @@ pub struct ChannelStateData {
     #[prost(message, optional, tag = "2")]
     pub channel: ::core::option::Option<super::super::super::core::channel::v1::Channel>,
 }
-impl ::prost::Name for ChannelStateData {
-    const NAME: &'static str = "ChannelStateData";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v1.ChannelStateData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v1.ChannelStateData".into()
-    }
-}
 /// PacketCommitmentData returns the SignBytes data for packet commitment
 /// verification.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -286,16 +166,6 @@ pub struct PacketCommitmentData {
     #[prost(bytes = "vec", tag = "2")]
     pub commitment: ::prost::alloc::vec::Vec<u8>,
 }
-impl ::prost::Name for PacketCommitmentData {
-    const NAME: &'static str = "PacketCommitmentData";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v1.PacketCommitmentData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v1.PacketCommitmentData".into()
-    }
-}
 /// PacketAcknowledgementData returns the SignBytes data for acknowledgement
 /// verification.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -306,16 +176,6 @@ pub struct PacketAcknowledgementData {
     #[prost(bytes = "vec", tag = "2")]
     pub acknowledgement: ::prost::alloc::vec::Vec<u8>,
 }
-impl ::prost::Name for PacketAcknowledgementData {
-    const NAME: &'static str = "PacketAcknowledgementData";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v1.PacketAcknowledgementData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v1.PacketAcknowledgementData".into()
-    }
-}
 /// PacketReceiptAbsenceData returns the SignBytes data for
 /// packet receipt absence verification.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -324,16 +184,6 @@ pub struct PacketReceiptAbsenceData {
     #[prost(bytes = "vec", tag = "1")]
     pub path: ::prost::alloc::vec::Vec<u8>,
 }
-impl ::prost::Name for PacketReceiptAbsenceData {
-    const NAME: &'static str = "PacketReceiptAbsenceData";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v1.PacketReceiptAbsenceData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v1.PacketReceiptAbsenceData".into()
-    }
-}
 /// NextSequenceRecvData returns the SignBytes data for verification of the next
 /// sequence to be received.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -344,16 +194,6 @@ pub struct NextSequenceRecvData {
     #[prost(uint64, tag = "2")]
     pub next_seq_recv: u64,
 }
-impl ::prost::Name for NextSequenceRecvData {
-    const NAME: &'static str = "NextSequenceRecvData";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v1.NextSequenceRecvData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v1.NextSequenceRecvData".into()
-    }
-}
 /// DataType defines the type of solo machine proof being created. This is done
 /// to preserve uniqueness of different data sign byte encodings.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
@@ -416,3 +256,5 @@ impl DataType {
         }
     }
 }
+include!("ibc.lightclients.solomachine.v1.serde.rs");
+// @@protoc_insertion_point(module)
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.solomachine.v1.serde.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.solomachine.v1.serde.rs
new file mode 100644
index 00000000..5753003b
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.solomachine.v1.serde.rs
@@ -0,0 +1,2369 @@
+// @generated
+#[cfg(feature = "serde")]
+impl serde::Serialize for ChannelStateData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.path.is_empty() {
+            len += 1;
+        }
+        if self.channel.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.solomachine.v1.ChannelStateData", len)?;
+        if !self.path.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
+        }
+        if let Some(v) = self.channel.as_ref() {
+            struct_ser.serialize_field("channel", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ChannelStateData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["path", "channel"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Path,
+            Channel,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "path" => Ok(GeneratedField::Path),
+                            "channel" => Ok(GeneratedField::Channel),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ChannelStateData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v1.ChannelStateData")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChannelStateData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut path__ = None;
+                let mut channel__ = 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::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Channel => {
+                            if channel__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channel"));
+                            }
+                            channel__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(ChannelStateData {
+                    path: path__.unwrap_or_default(),
+                    channel: channel__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v1.ChannelStateData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for ClientState {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.sequence != 0 {
+            len += 1;
+        }
+        if self.frozen_sequence != 0 {
+            len += 1;
+        }
+        if self.consensus_state.is_some() {
+            len += 1;
+        }
+        if self.allow_update_after_proposal {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.solomachine.v1.ClientState", len)?;
+        if self.sequence != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("sequence", ToString::to_string(&self.sequence).as_str())?;
+        }
+        if self.frozen_sequence != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "frozenSequence",
+                ToString::to_string(&self.frozen_sequence).as_str(),
+            )?;
+        }
+        if let Some(v) = self.consensus_state.as_ref() {
+            struct_ser.serialize_field("consensusState", v)?;
+        }
+        if self.allow_update_after_proposal {
+            struct_ser.serialize_field(
+                "allowUpdateAfterProposal",
+                &self.allow_update_after_proposal,
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ClientState {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "sequence",
+            "frozen_sequence",
+            "frozenSequence",
+            "consensus_state",
+            "consensusState",
+            "allow_update_after_proposal",
+            "allowUpdateAfterProposal",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Sequence,
+            FrozenSequence,
+            ConsensusState,
+            AllowUpdateAfterProposal,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "sequence" => Ok(GeneratedField::Sequence),
+                            "frozenSequence" | "frozen_sequence" => {
+                                Ok(GeneratedField::FrozenSequence)
+                            }
+                            "consensusState" | "consensus_state" => {
+                                Ok(GeneratedField::ConsensusState)
+                            }
+                            "allowUpdateAfterProposal" | "allow_update_after_proposal" => {
+                                Ok(GeneratedField::AllowUpdateAfterProposal)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ClientState;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v1.ClientState")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClientState, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut sequence__ = None;
+                let mut frozen_sequence__ = None;
+                let mut consensus_state__ = None;
+                let mut allow_update_after_proposal__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Sequence => {
+                            if sequence__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sequence"));
+                            }
+                            sequence__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::FrozenSequence => {
+                            if frozen_sequence__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("frozenSequence"));
+                            }
+                            frozen_sequence__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::ConsensusState => {
+                            if consensus_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("consensusState"));
+                            }
+                            consensus_state__ = map_.next_value()?;
+                        }
+                        GeneratedField::AllowUpdateAfterProposal => {
+                            if allow_update_after_proposal__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "allowUpdateAfterProposal",
+                                ));
+                            }
+                            allow_update_after_proposal__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(ClientState {
+                    sequence: sequence__.unwrap_or_default(),
+                    frozen_sequence: frozen_sequence__.unwrap_or_default(),
+                    consensus_state: consensus_state__,
+                    allow_update_after_proposal: allow_update_after_proposal__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v1.ClientState",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for ClientStateData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.path.is_empty() {
+            len += 1;
+        }
+        if self.client_state.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.solomachine.v1.ClientStateData", len)?;
+        if !self.path.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
+        }
+        if let Some(v) = self.client_state.as_ref() {
+            struct_ser.serialize_field("clientState", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ClientStateData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["path", "client_state", "clientState"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Path,
+            ClientState,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "path" => Ok(GeneratedField::Path),
+                            "clientState" | "client_state" => Ok(GeneratedField::ClientState),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ClientStateData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v1.ClientStateData")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClientStateData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut path__ = None;
+                let mut client_state__ = 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::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::ClientState => {
+                            if client_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("clientState"));
+                            }
+                            client_state__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(ClientStateData {
+                    path: path__.unwrap_or_default(),
+                    client_state: client_state__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v1.ClientStateData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for ConnectionStateData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.path.is_empty() {
+            len += 1;
+        }
+        if self.connection.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.lightclients.solomachine.v1.ConnectionStateData", len)?;
+        if !self.path.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
+        }
+        if let Some(v) = self.connection.as_ref() {
+            struct_ser.serialize_field("connection", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ConnectionStateData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["path", "connection"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Path,
+            Connection,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "path" => Ok(GeneratedField::Path),
+                            "connection" => Ok(GeneratedField::Connection),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ConnectionStateData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v1.ConnectionStateData")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectionStateData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut path__ = None;
+                let mut connection__ = 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::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Connection => {
+                            if connection__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("connection"));
+                            }
+                            connection__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(ConnectionStateData {
+                    path: path__.unwrap_or_default(),
+                    connection: connection__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v1.ConnectionStateData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for ConsensusState {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.public_key.is_some() {
+            len += 1;
+        }
+        if !self.diversifier.is_empty() {
+            len += 1;
+        }
+        if self.timestamp != 0 {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.solomachine.v1.ConsensusState", len)?;
+        if let Some(v) = self.public_key.as_ref() {
+            struct_ser.serialize_field("publicKey", v)?;
+        }
+        if !self.diversifier.is_empty() {
+            struct_ser.serialize_field("diversifier", &self.diversifier)?;
+        }
+        if self.timestamp != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("timestamp", ToString::to_string(&self.timestamp).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ConsensusState {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["public_key", "publicKey", "diversifier", "timestamp"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PublicKey,
+            Diversifier,
+            Timestamp,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "publicKey" | "public_key" => Ok(GeneratedField::PublicKey),
+                            "diversifier" => Ok(GeneratedField::Diversifier),
+                            "timestamp" => Ok(GeneratedField::Timestamp),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ConsensusState;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v1.ConsensusState")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConsensusState, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut public_key__ = None;
+                let mut diversifier__ = None;
+                let mut timestamp__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PublicKey => {
+                            if public_key__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("publicKey"));
+                            }
+                            public_key__ = map_.next_value()?;
+                        }
+                        GeneratedField::Diversifier => {
+                            if diversifier__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("diversifier"));
+                            }
+                            diversifier__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Timestamp => {
+                            if timestamp__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timestamp"));
+                            }
+                            timestamp__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(ConsensusState {
+                    public_key: public_key__,
+                    diversifier: diversifier__.unwrap_or_default(),
+                    timestamp: timestamp__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v1.ConsensusState",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for ConsensusStateData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.path.is_empty() {
+            len += 1;
+        }
+        if self.consensus_state.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.lightclients.solomachine.v1.ConsensusStateData", len)?;
+        if !self.path.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
+        }
+        if let Some(v) = self.consensus_state.as_ref() {
+            struct_ser.serialize_field("consensusState", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ConsensusStateData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["path", "consensus_state", "consensusState"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Path,
+            ConsensusState,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "path" => Ok(GeneratedField::Path),
+                            "consensusState" | "consensus_state" => {
+                                Ok(GeneratedField::ConsensusState)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ConsensusStateData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v1.ConsensusStateData")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConsensusStateData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut path__ = None;
+                let mut consensus_state__ = 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::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::ConsensusState => {
+                            if consensus_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("consensusState"));
+                            }
+                            consensus_state__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(ConsensusStateData {
+                    path: path__.unwrap_or_default(),
+                    consensus_state: consensus_state__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v1.ConsensusStateData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for DataType {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::UninitializedUnspecified => "DATA_TYPE_UNINITIALIZED_UNSPECIFIED",
+            Self::ClientState => "DATA_TYPE_CLIENT_STATE",
+            Self::ConsensusState => "DATA_TYPE_CONSENSUS_STATE",
+            Self::ConnectionState => "DATA_TYPE_CONNECTION_STATE",
+            Self::ChannelState => "DATA_TYPE_CHANNEL_STATE",
+            Self::PacketCommitment => "DATA_TYPE_PACKET_COMMITMENT",
+            Self::PacketAcknowledgement => "DATA_TYPE_PACKET_ACKNOWLEDGEMENT",
+            Self::PacketReceiptAbsence => "DATA_TYPE_PACKET_RECEIPT_ABSENCE",
+            Self::NextSequenceRecv => "DATA_TYPE_NEXT_SEQUENCE_RECV",
+            Self::Header => "DATA_TYPE_HEADER",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for DataType {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "DATA_TYPE_UNINITIALIZED_UNSPECIFIED",
+            "DATA_TYPE_CLIENT_STATE",
+            "DATA_TYPE_CONSENSUS_STATE",
+            "DATA_TYPE_CONNECTION_STATE",
+            "DATA_TYPE_CHANNEL_STATE",
+            "DATA_TYPE_PACKET_COMMITMENT",
+            "DATA_TYPE_PACKET_ACKNOWLEDGEMENT",
+            "DATA_TYPE_PACKET_RECEIPT_ABSENCE",
+            "DATA_TYPE_NEXT_SEQUENCE_RECV",
+            "DATA_TYPE_HEADER",
+        ];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = DataType;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                i32::try_from(v)
+                    .ok()
+                    .and_then(|x| x.try_into().ok())
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                i32::try_from(v)
+                    .ok()
+                    .and_then(|x| x.try_into().ok())
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "DATA_TYPE_UNINITIALIZED_UNSPECIFIED" => Ok(DataType::UninitializedUnspecified),
+                    "DATA_TYPE_CLIENT_STATE" => Ok(DataType::ClientState),
+                    "DATA_TYPE_CONSENSUS_STATE" => Ok(DataType::ConsensusState),
+                    "DATA_TYPE_CONNECTION_STATE" => Ok(DataType::ConnectionState),
+                    "DATA_TYPE_CHANNEL_STATE" => Ok(DataType::ChannelState),
+                    "DATA_TYPE_PACKET_COMMITMENT" => Ok(DataType::PacketCommitment),
+                    "DATA_TYPE_PACKET_ACKNOWLEDGEMENT" => Ok(DataType::PacketAcknowledgement),
+                    "DATA_TYPE_PACKET_RECEIPT_ABSENCE" => Ok(DataType::PacketReceiptAbsence),
+                    "DATA_TYPE_NEXT_SEQUENCE_RECV" => Ok(DataType::NextSequenceRecv),
+                    "DATA_TYPE_HEADER" => Ok(DataType::Header),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Header {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.sequence != 0 {
+            len += 1;
+        }
+        if self.timestamp != 0 {
+            len += 1;
+        }
+        if !self.signature.is_empty() {
+            len += 1;
+        }
+        if self.new_public_key.is_some() {
+            len += 1;
+        }
+        if !self.new_diversifier.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.solomachine.v1.Header", len)?;
+        if self.sequence != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("sequence", ToString::to_string(&self.sequence).as_str())?;
+        }
+        if self.timestamp != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("timestamp", ToString::to_string(&self.timestamp).as_str())?;
+        }
+        if !self.signature.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "signature",
+                pbjson::private::base64::encode(&self.signature).as_str(),
+            )?;
+        }
+        if let Some(v) = self.new_public_key.as_ref() {
+            struct_ser.serialize_field("newPublicKey", v)?;
+        }
+        if !self.new_diversifier.is_empty() {
+            struct_ser.serialize_field("newDiversifier", &self.new_diversifier)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Header {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "sequence",
+            "timestamp",
+            "signature",
+            "new_public_key",
+            "newPublicKey",
+            "new_diversifier",
+            "newDiversifier",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Sequence,
+            Timestamp,
+            Signature,
+            NewPublicKey,
+            NewDiversifier,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "sequence" => Ok(GeneratedField::Sequence),
+                            "timestamp" => Ok(GeneratedField::Timestamp),
+                            "signature" => Ok(GeneratedField::Signature),
+                            "newPublicKey" | "new_public_key" => Ok(GeneratedField::NewPublicKey),
+                            "newDiversifier" | "new_diversifier" => {
+                                Ok(GeneratedField::NewDiversifier)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Header;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v1.Header")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Header, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut sequence__ = None;
+                let mut timestamp__ = None;
+                let mut signature__ = None;
+                let mut new_public_key__ = None;
+                let mut new_diversifier__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Sequence => {
+                            if sequence__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sequence"));
+                            }
+                            sequence__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Timestamp => {
+                            if timestamp__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timestamp"));
+                            }
+                            timestamp__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Signature => {
+                            if signature__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signature"));
+                            }
+                            signature__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::NewPublicKey => {
+                            if new_public_key__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("newPublicKey"));
+                            }
+                            new_public_key__ = map_.next_value()?;
+                        }
+                        GeneratedField::NewDiversifier => {
+                            if new_diversifier__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("newDiversifier"));
+                            }
+                            new_diversifier__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(Header {
+                    sequence: sequence__.unwrap_or_default(),
+                    timestamp: timestamp__.unwrap_or_default(),
+                    signature: signature__.unwrap_or_default(),
+                    new_public_key: new_public_key__,
+                    new_diversifier: new_diversifier__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v1.Header",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for HeaderData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.new_pub_key.is_some() {
+            len += 1;
+        }
+        if !self.new_diversifier.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.solomachine.v1.HeaderData", len)?;
+        if let Some(v) = self.new_pub_key.as_ref() {
+            struct_ser.serialize_field("newPubKey", v)?;
+        }
+        if !self.new_diversifier.is_empty() {
+            struct_ser.serialize_field("newDiversifier", &self.new_diversifier)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for HeaderData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "new_pub_key",
+            "newPubKey",
+            "new_diversifier",
+            "newDiversifier",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            NewPubKey,
+            NewDiversifier,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "newPubKey" | "new_pub_key" => Ok(GeneratedField::NewPubKey),
+                            "newDiversifier" | "new_diversifier" => {
+                                Ok(GeneratedField::NewDiversifier)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = HeaderData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v1.HeaderData")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeaderData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut new_pub_key__ = None;
+                let mut new_diversifier__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::NewPubKey => {
+                            if new_pub_key__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("newPubKey"));
+                            }
+                            new_pub_key__ = map_.next_value()?;
+                        }
+                        GeneratedField::NewDiversifier => {
+                            if new_diversifier__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("newDiversifier"));
+                            }
+                            new_diversifier__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(HeaderData {
+                    new_pub_key: new_pub_key__,
+                    new_diversifier: new_diversifier__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v1.HeaderData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Misbehaviour {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        if self.sequence != 0 {
+            len += 1;
+        }
+        if self.signature_one.is_some() {
+            len += 1;
+        }
+        if self.signature_two.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.solomachine.v1.Misbehaviour", len)?;
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        if self.sequence != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("sequence", ToString::to_string(&self.sequence).as_str())?;
+        }
+        if let Some(v) = self.signature_one.as_ref() {
+            struct_ser.serialize_field("signatureOne", v)?;
+        }
+        if let Some(v) = self.signature_two.as_ref() {
+            struct_ser.serialize_field("signatureTwo", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Misbehaviour {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "client_id",
+            "clientId",
+            "sequence",
+            "signature_one",
+            "signatureOne",
+            "signature_two",
+            "signatureTwo",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientId,
+            Sequence,
+            SignatureOne,
+            SignatureTwo,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            "sequence" => Ok(GeneratedField::Sequence),
+                            "signatureOne" | "signature_one" => Ok(GeneratedField::SignatureOne),
+                            "signatureTwo" | "signature_two" => Ok(GeneratedField::SignatureTwo),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Misbehaviour;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v1.Misbehaviour")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Misbehaviour, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut client_id__ = None;
+                let mut sequence__ = None;
+                let mut signature_one__ = None;
+                let mut signature_two__ = 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::Sequence => {
+                            if sequence__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sequence"));
+                            }
+                            sequence__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::SignatureOne => {
+                            if signature_one__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signatureOne"));
+                            }
+                            signature_one__ = map_.next_value()?;
+                        }
+                        GeneratedField::SignatureTwo => {
+                            if signature_two__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signatureTwo"));
+                            }
+                            signature_two__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(Misbehaviour {
+                    client_id: client_id__.unwrap_or_default(),
+                    sequence: sequence__.unwrap_or_default(),
+                    signature_one: signature_one__,
+                    signature_two: signature_two__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v1.Misbehaviour",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for NextSequenceRecvData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.path.is_empty() {
+            len += 1;
+        }
+        if self.next_seq_recv != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.lightclients.solomachine.v1.NextSequenceRecvData", len)?;
+        if !self.path.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
+        }
+        if self.next_seq_recv != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "nextSeqRecv",
+                ToString::to_string(&self.next_seq_recv).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for NextSequenceRecvData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["path", "next_seq_recv", "nextSeqRecv"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Path,
+            NextSeqRecv,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "path" => Ok(GeneratedField::Path),
+                            "nextSeqRecv" | "next_seq_recv" => Ok(GeneratedField::NextSeqRecv),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = NextSequenceRecvData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v1.NextSequenceRecvData")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<NextSequenceRecvData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut path__ = None;
+                let mut next_seq_recv__ = 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::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::NextSeqRecv => {
+                            if next_seq_recv__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("nextSeqRecv"));
+                            }
+                            next_seq_recv__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(NextSequenceRecvData {
+                    path: path__.unwrap_or_default(),
+                    next_seq_recv: next_seq_recv__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v1.NextSequenceRecvData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for PacketAcknowledgementData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.path.is_empty() {
+            len += 1;
+        }
+        if !self.acknowledgement.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.lightclients.solomachine.v1.PacketAcknowledgementData",
+            len,
+        )?;
+        if !self.path.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
+        }
+        if !self.acknowledgement.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "acknowledgement",
+                pbjson::private::base64::encode(&self.acknowledgement).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for PacketAcknowledgementData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["path", "acknowledgement"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Path,
+            Acknowledgement,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "path" => Ok(GeneratedField::Path),
+                            "acknowledgement" => Ok(GeneratedField::Acknowledgement),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PacketAcknowledgementData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter
+                    .write_str("struct ibc.lightclients.solomachine.v1.PacketAcknowledgementData")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<PacketAcknowledgementData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut path__ = None;
+                let mut acknowledgement__ = 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::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Acknowledgement => {
+                            if acknowledgement__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("acknowledgement"));
+                            }
+                            acknowledgement__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(PacketAcknowledgementData {
+                    path: path__.unwrap_or_default(),
+                    acknowledgement: acknowledgement__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v1.PacketAcknowledgementData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for PacketCommitmentData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.path.is_empty() {
+            len += 1;
+        }
+        if !self.commitment.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.lightclients.solomachine.v1.PacketCommitmentData", len)?;
+        if !self.path.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
+        }
+        if !self.commitment.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "commitment",
+                pbjson::private::base64::encode(&self.commitment).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for PacketCommitmentData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["path", "commitment"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Path,
+            Commitment,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "path" => Ok(GeneratedField::Path),
+                            "commitment" => Ok(GeneratedField::Commitment),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PacketCommitmentData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v1.PacketCommitmentData")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<PacketCommitmentData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut path__ = None;
+                let mut commitment__ = 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::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Commitment => {
+                            if commitment__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("commitment"));
+                            }
+                            commitment__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(PacketCommitmentData {
+                    path: path__.unwrap_or_default(),
+                    commitment: commitment__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v1.PacketCommitmentData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for PacketReceiptAbsenceData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.path.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.lightclients.solomachine.v1.PacketReceiptAbsenceData",
+            len,
+        )?;
+        if !self.path.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for PacketReceiptAbsenceData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["path"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Path,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "path" => Ok(GeneratedField::Path),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PacketReceiptAbsenceData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter
+                    .write_str("struct ibc.lightclients.solomachine.v1.PacketReceiptAbsenceData")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<PacketReceiptAbsenceData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut path__ = 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::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(PacketReceiptAbsenceData {
+                    path: path__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v1.PacketReceiptAbsenceData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for SignBytes {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.sequence != 0 {
+            len += 1;
+        }
+        if self.timestamp != 0 {
+            len += 1;
+        }
+        if !self.diversifier.is_empty() {
+            len += 1;
+        }
+        if self.data_type != 0 {
+            len += 1;
+        }
+        if !self.data.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.solomachine.v1.SignBytes", len)?;
+        if self.sequence != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("sequence", ToString::to_string(&self.sequence).as_str())?;
+        }
+        if self.timestamp != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("timestamp", ToString::to_string(&self.timestamp).as_str())?;
+        }
+        if !self.diversifier.is_empty() {
+            struct_ser.serialize_field("diversifier", &self.diversifier)?;
+        }
+        if self.data_type != 0 {
+            let v = DataType::try_from(self.data_type).map_err(|_| {
+                serde::ser::Error::custom(format!("Invalid variant {}", self.data_type))
+            })?;
+            struct_ser.serialize_field("dataType", &v)?;
+        }
+        if !self.data.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for SignBytes {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "sequence",
+            "timestamp",
+            "diversifier",
+            "data_type",
+            "dataType",
+            "data",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Sequence,
+            Timestamp,
+            Diversifier,
+            DataType,
+            Data,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "sequence" => Ok(GeneratedField::Sequence),
+                            "timestamp" => Ok(GeneratedField::Timestamp),
+                            "diversifier" => Ok(GeneratedField::Diversifier),
+                            "dataType" | "data_type" => Ok(GeneratedField::DataType),
+                            "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 = SignBytes;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v1.SignBytes")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SignBytes, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut sequence__ = None;
+                let mut timestamp__ = None;
+                let mut diversifier__ = None;
+                let mut data_type__ = None;
+                let mut data__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Sequence => {
+                            if sequence__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sequence"));
+                            }
+                            sequence__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Timestamp => {
+                            if timestamp__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timestamp"));
+                            }
+                            timestamp__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Diversifier => {
+                            if diversifier__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("diversifier"));
+                            }
+                            diversifier__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::DataType => {
+                            if data_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("dataType"));
+                            }
+                            data_type__ = Some(map_.next_value::<DataType>()? as i32);
+                        }
+                        GeneratedField::Data => {
+                            if data__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("data"));
+                            }
+                            data__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(SignBytes {
+                    sequence: sequence__.unwrap_or_default(),
+                    timestamp: timestamp__.unwrap_or_default(),
+                    diversifier: diversifier__.unwrap_or_default(),
+                    data_type: data_type__.unwrap_or_default(),
+                    data: data__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v1.SignBytes",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for SignatureAndData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.signature.is_empty() {
+            len += 1;
+        }
+        if self.data_type != 0 {
+            len += 1;
+        }
+        if !self.data.is_empty() {
+            len += 1;
+        }
+        if self.timestamp != 0 {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.solomachine.v1.SignatureAndData", len)?;
+        if !self.signature.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "signature",
+                pbjson::private::base64::encode(&self.signature).as_str(),
+            )?;
+        }
+        if self.data_type != 0 {
+            let v = DataType::try_from(self.data_type).map_err(|_| {
+                serde::ser::Error::custom(format!("Invalid variant {}", self.data_type))
+            })?;
+            struct_ser.serialize_field("dataType", &v)?;
+        }
+        if !self.data.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?;
+        }
+        if self.timestamp != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("timestamp", ToString::to_string(&self.timestamp).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for SignatureAndData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["signature", "data_type", "dataType", "data", "timestamp"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Signature,
+            DataType,
+            Data,
+            Timestamp,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "signature" => Ok(GeneratedField::Signature),
+                            "dataType" | "data_type" => Ok(GeneratedField::DataType),
+                            "data" => Ok(GeneratedField::Data),
+                            "timestamp" => Ok(GeneratedField::Timestamp),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = SignatureAndData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v1.SignatureAndData")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SignatureAndData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut signature__ = None;
+                let mut data_type__ = None;
+                let mut data__ = None;
+                let mut timestamp__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Signature => {
+                            if signature__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signature"));
+                            }
+                            signature__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::DataType => {
+                            if data_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("dataType"));
+                            }
+                            data_type__ = Some(map_.next_value::<DataType>()? as i32);
+                        }
+                        GeneratedField::Data => {
+                            if data__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("data"));
+                            }
+                            data__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Timestamp => {
+                            if timestamp__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timestamp"));
+                            }
+                            timestamp__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(SignatureAndData {
+                    signature: signature__.unwrap_or_default(),
+                    data_type: data_type__.unwrap_or_default(),
+                    data: data__.unwrap_or_default(),
+                    timestamp: timestamp__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v1.SignatureAndData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for TimestampedSignatureData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.signature_data.is_empty() {
+            len += 1;
+        }
+        if self.timestamp != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.lightclients.solomachine.v1.TimestampedSignatureData",
+            len,
+        )?;
+        if !self.signature_data.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "signatureData",
+                pbjson::private::base64::encode(&self.signature_data).as_str(),
+            )?;
+        }
+        if self.timestamp != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("timestamp", ToString::to_string(&self.timestamp).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for TimestampedSignatureData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["signature_data", "signatureData", "timestamp"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            SignatureData,
+            Timestamp,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "signatureData" | "signature_data" => Ok(GeneratedField::SignatureData),
+                            "timestamp" => Ok(GeneratedField::Timestamp),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = TimestampedSignatureData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter
+                    .write_str("struct ibc.lightclients.solomachine.v1.TimestampedSignatureData")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<TimestampedSignatureData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut signature_data__ = None;
+                let mut timestamp__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::SignatureData => {
+                            if signature_data__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signatureData"));
+                            }
+                            signature_data__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Timestamp => {
+                            if timestamp__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timestamp"));
+                            }
+                            timestamp__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(TimestampedSignatureData {
+                    signature_data: signature_data__.unwrap_or_default(),
+                    timestamp: timestamp__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v1.TimestampedSignatureData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.solomachine.v2.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.solomachine.v2.rs
index 1b4120c6..9a1db9a9 100644
--- a/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.solomachine.v2.rs
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.solomachine.v2.rs
@@ -1,4 +1,4 @@
-// This file is @generated by prost-build.
+// @generated
 /// ClientState defines a solo machine client that tracks the current consensus
 /// state and if the client is frozen.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -17,16 +17,6 @@ pub struct ClientState {
     #[prost(bool, tag = "4")]
     pub allow_update_after_proposal: bool,
 }
-impl ::prost::Name for ClientState {
-    const NAME: &'static str = "ClientState";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v2.ClientState".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v2.ClientState".into()
-    }
-}
 /// ConsensusState defines a solo machine consensus state. The sequence of a
 /// consensus state is contained in the "height" key used in storing the
 /// consensus state.
@@ -44,16 +34,6 @@ pub struct ConsensusState {
     #[prost(uint64, tag = "3")]
     pub timestamp: u64,
 }
-impl ::prost::Name for ConsensusState {
-    const NAME: &'static str = "ConsensusState";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v2.ConsensusState".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v2.ConsensusState".into()
-    }
-}
 /// Header defines a solo machine consensus header
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -70,16 +50,6 @@ pub struct Header {
     #[prost(string, tag = "5")]
     pub new_diversifier: ::prost::alloc::string::String,
 }
-impl ::prost::Name for Header {
-    const NAME: &'static str = "Header";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v2.Header".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v2.Header".into()
-    }
-}
 /// Misbehaviour defines misbehaviour for a solo machine which consists
 /// of a sequence and two signatures over different messages at that sequence.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -94,16 +64,6 @@ pub struct Misbehaviour {
     #[prost(message, optional, tag = "4")]
     pub signature_two: ::core::option::Option<SignatureAndData>,
 }
-impl ::prost::Name for Misbehaviour {
-    const NAME: &'static str = "Misbehaviour";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v2.Misbehaviour".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v2.Misbehaviour".into()
-    }
-}
 /// SignatureAndData contains a signature and the data signed over to create that
 /// signature.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -118,16 +78,6 @@ pub struct SignatureAndData {
     #[prost(uint64, tag = "4")]
     pub timestamp: u64,
 }
-impl ::prost::Name for SignatureAndData {
-    const NAME: &'static str = "SignatureAndData";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v2.SignatureAndData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v2.SignatureAndData".into()
-    }
-}
 /// TimestampedSignatureData contains the signature data and the timestamp of the
 /// signature.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -138,16 +88,6 @@ pub struct TimestampedSignatureData {
     #[prost(uint64, tag = "2")]
     pub timestamp: u64,
 }
-impl ::prost::Name for TimestampedSignatureData {
-    const NAME: &'static str = "TimestampedSignatureData";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v2.TimestampedSignatureData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v2.TimestampedSignatureData".into()
-    }
-}
 /// SignBytes defines the signed bytes used for signature verification.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -165,16 +105,6 @@ pub struct SignBytes {
     #[prost(bytes = "vec", tag = "5")]
     pub data: ::prost::alloc::vec::Vec<u8>,
 }
-impl ::prost::Name for SignBytes {
-    const NAME: &'static str = "SignBytes";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v2.SignBytes".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v2.SignBytes".into()
-    }
-}
 /// HeaderData returns the SignBytes data for update verification.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -186,16 +116,6 @@ pub struct HeaderData {
     #[prost(string, tag = "2")]
     pub new_diversifier: ::prost::alloc::string::String,
 }
-impl ::prost::Name for HeaderData {
-    const NAME: &'static str = "HeaderData";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v2.HeaderData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v2.HeaderData".into()
-    }
-}
 /// ClientStateData returns the SignBytes data for client state verification.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -205,16 +125,6 @@ pub struct ClientStateData {
     #[prost(message, optional, tag = "2")]
     pub client_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
 }
-impl ::prost::Name for ClientStateData {
-    const NAME: &'static str = "ClientStateData";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v2.ClientStateData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v2.ClientStateData".into()
-    }
-}
 /// ConsensusStateData returns the SignBytes data for consensus state
 /// verification.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -225,16 +135,6 @@ pub struct ConsensusStateData {
     #[prost(message, optional, tag = "2")]
     pub consensus_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
 }
-impl ::prost::Name for ConsensusStateData {
-    const NAME: &'static str = "ConsensusStateData";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v2.ConsensusStateData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v2.ConsensusStateData".into()
-    }
-}
 /// ConnectionStateData returns the SignBytes data for connection state
 /// verification.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -246,16 +146,6 @@ pub struct ConnectionStateData {
     pub connection:
         ::core::option::Option<super::super::super::core::connection::v1::ConnectionEnd>,
 }
-impl ::prost::Name for ConnectionStateData {
-    const NAME: &'static str = "ConnectionStateData";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v2.ConnectionStateData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v2.ConnectionStateData".into()
-    }
-}
 /// ChannelStateData returns the SignBytes data for channel state
 /// verification.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -266,16 +156,6 @@ pub struct ChannelStateData {
     #[prost(message, optional, tag = "2")]
     pub channel: ::core::option::Option<super::super::super::core::channel::v1::Channel>,
 }
-impl ::prost::Name for ChannelStateData {
-    const NAME: &'static str = "ChannelStateData";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v2.ChannelStateData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v2.ChannelStateData".into()
-    }
-}
 /// PacketCommitmentData returns the SignBytes data for packet commitment
 /// verification.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -286,16 +166,6 @@ pub struct PacketCommitmentData {
     #[prost(bytes = "vec", tag = "2")]
     pub commitment: ::prost::alloc::vec::Vec<u8>,
 }
-impl ::prost::Name for PacketCommitmentData {
-    const NAME: &'static str = "PacketCommitmentData";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v2.PacketCommitmentData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v2.PacketCommitmentData".into()
-    }
-}
 /// PacketAcknowledgementData returns the SignBytes data for acknowledgement
 /// verification.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -306,16 +176,6 @@ pub struct PacketAcknowledgementData {
     #[prost(bytes = "vec", tag = "2")]
     pub acknowledgement: ::prost::alloc::vec::Vec<u8>,
 }
-impl ::prost::Name for PacketAcknowledgementData {
-    const NAME: &'static str = "PacketAcknowledgementData";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v2.PacketAcknowledgementData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v2.PacketAcknowledgementData".into()
-    }
-}
 /// PacketReceiptAbsenceData returns the SignBytes data for
 /// packet receipt absence verification.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -324,16 +184,6 @@ pub struct PacketReceiptAbsenceData {
     #[prost(bytes = "vec", tag = "1")]
     pub path: ::prost::alloc::vec::Vec<u8>,
 }
-impl ::prost::Name for PacketReceiptAbsenceData {
-    const NAME: &'static str = "PacketReceiptAbsenceData";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v2.PacketReceiptAbsenceData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v2.PacketReceiptAbsenceData".into()
-    }
-}
 /// NextSequenceRecvData returns the SignBytes data for verification of the next
 /// sequence to be received.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -344,16 +194,6 @@ pub struct NextSequenceRecvData {
     #[prost(uint64, tag = "2")]
     pub next_seq_recv: u64,
 }
-impl ::prost::Name for NextSequenceRecvData {
-    const NAME: &'static str = "NextSequenceRecvData";
-    const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.solomachine.v2.NextSequenceRecvData".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.solomachine.v2.NextSequenceRecvData".into()
-    }
-}
 /// DataType defines the type of solo machine proof being created. This is done
 /// to preserve uniqueness of different data sign byte encodings.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
@@ -416,3 +256,5 @@ impl DataType {
         }
     }
 }
+include!("ibc.lightclients.solomachine.v2.serde.rs");
+// @@protoc_insertion_point(module)
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.solomachine.v2.serde.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.solomachine.v2.serde.rs
new file mode 100644
index 00000000..bc14e3d9
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.solomachine.v2.serde.rs
@@ -0,0 +1,2360 @@
+// @generated
+#[cfg(feature = "serde")]
+impl serde::Serialize for ChannelStateData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.path.is_empty() {
+            len += 1;
+        }
+        if self.channel.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.solomachine.v2.ChannelStateData", len)?;
+        if !self.path.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
+        }
+        if let Some(v) = self.channel.as_ref() {
+            struct_ser.serialize_field("channel", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ChannelStateData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["path", "channel"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Path,
+            Channel,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "path" => Ok(GeneratedField::Path),
+                            "channel" => Ok(GeneratedField::Channel),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ChannelStateData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v2.ChannelStateData")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChannelStateData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut path__ = None;
+                let mut channel__ = 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::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Channel => {
+                            if channel__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("channel"));
+                            }
+                            channel__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(ChannelStateData {
+                    path: path__.unwrap_or_default(),
+                    channel: channel__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v2.ChannelStateData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for ClientState {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.sequence != 0 {
+            len += 1;
+        }
+        if self.is_frozen {
+            len += 1;
+        }
+        if self.consensus_state.is_some() {
+            len += 1;
+        }
+        if self.allow_update_after_proposal {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.solomachine.v2.ClientState", len)?;
+        if self.sequence != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("sequence", ToString::to_string(&self.sequence).as_str())?;
+        }
+        if self.is_frozen {
+            struct_ser.serialize_field("isFrozen", &self.is_frozen)?;
+        }
+        if let Some(v) = self.consensus_state.as_ref() {
+            struct_ser.serialize_field("consensusState", v)?;
+        }
+        if self.allow_update_after_proposal {
+            struct_ser.serialize_field(
+                "allowUpdateAfterProposal",
+                &self.allow_update_after_proposal,
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ClientState {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "sequence",
+            "is_frozen",
+            "isFrozen",
+            "consensus_state",
+            "consensusState",
+            "allow_update_after_proposal",
+            "allowUpdateAfterProposal",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Sequence,
+            IsFrozen,
+            ConsensusState,
+            AllowUpdateAfterProposal,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "sequence" => Ok(GeneratedField::Sequence),
+                            "isFrozen" | "is_frozen" => Ok(GeneratedField::IsFrozen),
+                            "consensusState" | "consensus_state" => {
+                                Ok(GeneratedField::ConsensusState)
+                            }
+                            "allowUpdateAfterProposal" | "allow_update_after_proposal" => {
+                                Ok(GeneratedField::AllowUpdateAfterProposal)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ClientState;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v2.ClientState")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClientState, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut sequence__ = None;
+                let mut is_frozen__ = None;
+                let mut consensus_state__ = None;
+                let mut allow_update_after_proposal__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Sequence => {
+                            if sequence__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sequence"));
+                            }
+                            sequence__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::IsFrozen => {
+                            if is_frozen__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("isFrozen"));
+                            }
+                            is_frozen__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::ConsensusState => {
+                            if consensus_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("consensusState"));
+                            }
+                            consensus_state__ = map_.next_value()?;
+                        }
+                        GeneratedField::AllowUpdateAfterProposal => {
+                            if allow_update_after_proposal__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "allowUpdateAfterProposal",
+                                ));
+                            }
+                            allow_update_after_proposal__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(ClientState {
+                    sequence: sequence__.unwrap_or_default(),
+                    is_frozen: is_frozen__.unwrap_or_default(),
+                    consensus_state: consensus_state__,
+                    allow_update_after_proposal: allow_update_after_proposal__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v2.ClientState",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for ClientStateData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.path.is_empty() {
+            len += 1;
+        }
+        if self.client_state.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.solomachine.v2.ClientStateData", len)?;
+        if !self.path.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
+        }
+        if let Some(v) = self.client_state.as_ref() {
+            struct_ser.serialize_field("clientState", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ClientStateData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["path", "client_state", "clientState"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Path,
+            ClientState,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "path" => Ok(GeneratedField::Path),
+                            "clientState" | "client_state" => Ok(GeneratedField::ClientState),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ClientStateData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v2.ClientStateData")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClientStateData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut path__ = None;
+                let mut client_state__ = 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::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::ClientState => {
+                            if client_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("clientState"));
+                            }
+                            client_state__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(ClientStateData {
+                    path: path__.unwrap_or_default(),
+                    client_state: client_state__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v2.ClientStateData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for ConnectionStateData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.path.is_empty() {
+            len += 1;
+        }
+        if self.connection.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.lightclients.solomachine.v2.ConnectionStateData", len)?;
+        if !self.path.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
+        }
+        if let Some(v) = self.connection.as_ref() {
+            struct_ser.serialize_field("connection", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ConnectionStateData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["path", "connection"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Path,
+            Connection,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "path" => Ok(GeneratedField::Path),
+                            "connection" => Ok(GeneratedField::Connection),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ConnectionStateData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v2.ConnectionStateData")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectionStateData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut path__ = None;
+                let mut connection__ = 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::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Connection => {
+                            if connection__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("connection"));
+                            }
+                            connection__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(ConnectionStateData {
+                    path: path__.unwrap_or_default(),
+                    connection: connection__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v2.ConnectionStateData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for ConsensusState {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.public_key.is_some() {
+            len += 1;
+        }
+        if !self.diversifier.is_empty() {
+            len += 1;
+        }
+        if self.timestamp != 0 {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.solomachine.v2.ConsensusState", len)?;
+        if let Some(v) = self.public_key.as_ref() {
+            struct_ser.serialize_field("publicKey", v)?;
+        }
+        if !self.diversifier.is_empty() {
+            struct_ser.serialize_field("diversifier", &self.diversifier)?;
+        }
+        if self.timestamp != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("timestamp", ToString::to_string(&self.timestamp).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ConsensusState {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["public_key", "publicKey", "diversifier", "timestamp"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PublicKey,
+            Diversifier,
+            Timestamp,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "publicKey" | "public_key" => Ok(GeneratedField::PublicKey),
+                            "diversifier" => Ok(GeneratedField::Diversifier),
+                            "timestamp" => Ok(GeneratedField::Timestamp),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ConsensusState;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v2.ConsensusState")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConsensusState, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut public_key__ = None;
+                let mut diversifier__ = None;
+                let mut timestamp__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::PublicKey => {
+                            if public_key__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("publicKey"));
+                            }
+                            public_key__ = map_.next_value()?;
+                        }
+                        GeneratedField::Diversifier => {
+                            if diversifier__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("diversifier"));
+                            }
+                            diversifier__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::Timestamp => {
+                            if timestamp__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timestamp"));
+                            }
+                            timestamp__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(ConsensusState {
+                    public_key: public_key__,
+                    diversifier: diversifier__.unwrap_or_default(),
+                    timestamp: timestamp__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v2.ConsensusState",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for ConsensusStateData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.path.is_empty() {
+            len += 1;
+        }
+        if self.consensus_state.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.lightclients.solomachine.v2.ConsensusStateData", len)?;
+        if !self.path.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
+        }
+        if let Some(v) = self.consensus_state.as_ref() {
+            struct_ser.serialize_field("consensusState", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ConsensusStateData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["path", "consensus_state", "consensusState"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Path,
+            ConsensusState,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "path" => Ok(GeneratedField::Path),
+                            "consensusState" | "consensus_state" => {
+                                Ok(GeneratedField::ConsensusState)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ConsensusStateData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v2.ConsensusStateData")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConsensusStateData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut path__ = None;
+                let mut consensus_state__ = 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::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::ConsensusState => {
+                            if consensus_state__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("consensusState"));
+                            }
+                            consensus_state__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(ConsensusStateData {
+                    path: path__.unwrap_or_default(),
+                    consensus_state: consensus_state__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v2.ConsensusStateData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for DataType {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::UninitializedUnspecified => "DATA_TYPE_UNINITIALIZED_UNSPECIFIED",
+            Self::ClientState => "DATA_TYPE_CLIENT_STATE",
+            Self::ConsensusState => "DATA_TYPE_CONSENSUS_STATE",
+            Self::ConnectionState => "DATA_TYPE_CONNECTION_STATE",
+            Self::ChannelState => "DATA_TYPE_CHANNEL_STATE",
+            Self::PacketCommitment => "DATA_TYPE_PACKET_COMMITMENT",
+            Self::PacketAcknowledgement => "DATA_TYPE_PACKET_ACKNOWLEDGEMENT",
+            Self::PacketReceiptAbsence => "DATA_TYPE_PACKET_RECEIPT_ABSENCE",
+            Self::NextSequenceRecv => "DATA_TYPE_NEXT_SEQUENCE_RECV",
+            Self::Header => "DATA_TYPE_HEADER",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for DataType {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "DATA_TYPE_UNINITIALIZED_UNSPECIFIED",
+            "DATA_TYPE_CLIENT_STATE",
+            "DATA_TYPE_CONSENSUS_STATE",
+            "DATA_TYPE_CONNECTION_STATE",
+            "DATA_TYPE_CHANNEL_STATE",
+            "DATA_TYPE_PACKET_COMMITMENT",
+            "DATA_TYPE_PACKET_ACKNOWLEDGEMENT",
+            "DATA_TYPE_PACKET_RECEIPT_ABSENCE",
+            "DATA_TYPE_NEXT_SEQUENCE_RECV",
+            "DATA_TYPE_HEADER",
+        ];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = DataType;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                i32::try_from(v)
+                    .ok()
+                    .and_then(|x| x.try_into().ok())
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                i32::try_from(v)
+                    .ok()
+                    .and_then(|x| x.try_into().ok())
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "DATA_TYPE_UNINITIALIZED_UNSPECIFIED" => Ok(DataType::UninitializedUnspecified),
+                    "DATA_TYPE_CLIENT_STATE" => Ok(DataType::ClientState),
+                    "DATA_TYPE_CONSENSUS_STATE" => Ok(DataType::ConsensusState),
+                    "DATA_TYPE_CONNECTION_STATE" => Ok(DataType::ConnectionState),
+                    "DATA_TYPE_CHANNEL_STATE" => Ok(DataType::ChannelState),
+                    "DATA_TYPE_PACKET_COMMITMENT" => Ok(DataType::PacketCommitment),
+                    "DATA_TYPE_PACKET_ACKNOWLEDGEMENT" => Ok(DataType::PacketAcknowledgement),
+                    "DATA_TYPE_PACKET_RECEIPT_ABSENCE" => Ok(DataType::PacketReceiptAbsence),
+                    "DATA_TYPE_NEXT_SEQUENCE_RECV" => Ok(DataType::NextSequenceRecv),
+                    "DATA_TYPE_HEADER" => Ok(DataType::Header),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Header {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.sequence != 0 {
+            len += 1;
+        }
+        if self.timestamp != 0 {
+            len += 1;
+        }
+        if !self.signature.is_empty() {
+            len += 1;
+        }
+        if self.new_public_key.is_some() {
+            len += 1;
+        }
+        if !self.new_diversifier.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.solomachine.v2.Header", len)?;
+        if self.sequence != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("sequence", ToString::to_string(&self.sequence).as_str())?;
+        }
+        if self.timestamp != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("timestamp", ToString::to_string(&self.timestamp).as_str())?;
+        }
+        if !self.signature.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "signature",
+                pbjson::private::base64::encode(&self.signature).as_str(),
+            )?;
+        }
+        if let Some(v) = self.new_public_key.as_ref() {
+            struct_ser.serialize_field("newPublicKey", v)?;
+        }
+        if !self.new_diversifier.is_empty() {
+            struct_ser.serialize_field("newDiversifier", &self.new_diversifier)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Header {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "sequence",
+            "timestamp",
+            "signature",
+            "new_public_key",
+            "newPublicKey",
+            "new_diversifier",
+            "newDiversifier",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Sequence,
+            Timestamp,
+            Signature,
+            NewPublicKey,
+            NewDiversifier,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "sequence" => Ok(GeneratedField::Sequence),
+                            "timestamp" => Ok(GeneratedField::Timestamp),
+                            "signature" => Ok(GeneratedField::Signature),
+                            "newPublicKey" | "new_public_key" => Ok(GeneratedField::NewPublicKey),
+                            "newDiversifier" | "new_diversifier" => {
+                                Ok(GeneratedField::NewDiversifier)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Header;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v2.Header")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Header, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut sequence__ = None;
+                let mut timestamp__ = None;
+                let mut signature__ = None;
+                let mut new_public_key__ = None;
+                let mut new_diversifier__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Sequence => {
+                            if sequence__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sequence"));
+                            }
+                            sequence__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Timestamp => {
+                            if timestamp__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timestamp"));
+                            }
+                            timestamp__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Signature => {
+                            if signature__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signature"));
+                            }
+                            signature__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::NewPublicKey => {
+                            if new_public_key__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("newPublicKey"));
+                            }
+                            new_public_key__ = map_.next_value()?;
+                        }
+                        GeneratedField::NewDiversifier => {
+                            if new_diversifier__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("newDiversifier"));
+                            }
+                            new_diversifier__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(Header {
+                    sequence: sequence__.unwrap_or_default(),
+                    timestamp: timestamp__.unwrap_or_default(),
+                    signature: signature__.unwrap_or_default(),
+                    new_public_key: new_public_key__,
+                    new_diversifier: new_diversifier__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v2.Header",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for HeaderData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.new_pub_key.is_some() {
+            len += 1;
+        }
+        if !self.new_diversifier.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.solomachine.v2.HeaderData", len)?;
+        if let Some(v) = self.new_pub_key.as_ref() {
+            struct_ser.serialize_field("newPubKey", v)?;
+        }
+        if !self.new_diversifier.is_empty() {
+            struct_ser.serialize_field("newDiversifier", &self.new_diversifier)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for HeaderData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "new_pub_key",
+            "newPubKey",
+            "new_diversifier",
+            "newDiversifier",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            NewPubKey,
+            NewDiversifier,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "newPubKey" | "new_pub_key" => Ok(GeneratedField::NewPubKey),
+                            "newDiversifier" | "new_diversifier" => {
+                                Ok(GeneratedField::NewDiversifier)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = HeaderData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v2.HeaderData")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeaderData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut new_pub_key__ = None;
+                let mut new_diversifier__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::NewPubKey => {
+                            if new_pub_key__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("newPubKey"));
+                            }
+                            new_pub_key__ = map_.next_value()?;
+                        }
+                        GeneratedField::NewDiversifier => {
+                            if new_diversifier__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("newDiversifier"));
+                            }
+                            new_diversifier__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(HeaderData {
+                    new_pub_key: new_pub_key__,
+                    new_diversifier: new_diversifier__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v2.HeaderData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Misbehaviour {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        if self.sequence != 0 {
+            len += 1;
+        }
+        if self.signature_one.is_some() {
+            len += 1;
+        }
+        if self.signature_two.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.solomachine.v2.Misbehaviour", len)?;
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        if self.sequence != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("sequence", ToString::to_string(&self.sequence).as_str())?;
+        }
+        if let Some(v) = self.signature_one.as_ref() {
+            struct_ser.serialize_field("signatureOne", v)?;
+        }
+        if let Some(v) = self.signature_two.as_ref() {
+            struct_ser.serialize_field("signatureTwo", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Misbehaviour {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "client_id",
+            "clientId",
+            "sequence",
+            "signature_one",
+            "signatureOne",
+            "signature_two",
+            "signatureTwo",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientId,
+            Sequence,
+            SignatureOne,
+            SignatureTwo,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            "sequence" => Ok(GeneratedField::Sequence),
+                            "signatureOne" | "signature_one" => Ok(GeneratedField::SignatureOne),
+                            "signatureTwo" | "signature_two" => Ok(GeneratedField::SignatureTwo),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Misbehaviour;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v2.Misbehaviour")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Misbehaviour, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut client_id__ = None;
+                let mut sequence__ = None;
+                let mut signature_one__ = None;
+                let mut signature_two__ = 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::Sequence => {
+                            if sequence__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sequence"));
+                            }
+                            sequence__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::SignatureOne => {
+                            if signature_one__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signatureOne"));
+                            }
+                            signature_one__ = map_.next_value()?;
+                        }
+                        GeneratedField::SignatureTwo => {
+                            if signature_two__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signatureTwo"));
+                            }
+                            signature_two__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(Misbehaviour {
+                    client_id: client_id__.unwrap_or_default(),
+                    sequence: sequence__.unwrap_or_default(),
+                    signature_one: signature_one__,
+                    signature_two: signature_two__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v2.Misbehaviour",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for NextSequenceRecvData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.path.is_empty() {
+            len += 1;
+        }
+        if self.next_seq_recv != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.lightclients.solomachine.v2.NextSequenceRecvData", len)?;
+        if !self.path.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
+        }
+        if self.next_seq_recv != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "nextSeqRecv",
+                ToString::to_string(&self.next_seq_recv).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for NextSequenceRecvData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["path", "next_seq_recv", "nextSeqRecv"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Path,
+            NextSeqRecv,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "path" => Ok(GeneratedField::Path),
+                            "nextSeqRecv" | "next_seq_recv" => Ok(GeneratedField::NextSeqRecv),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = NextSequenceRecvData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v2.NextSequenceRecvData")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<NextSequenceRecvData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut path__ = None;
+                let mut next_seq_recv__ = 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::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::NextSeqRecv => {
+                            if next_seq_recv__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("nextSeqRecv"));
+                            }
+                            next_seq_recv__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(NextSequenceRecvData {
+                    path: path__.unwrap_or_default(),
+                    next_seq_recv: next_seq_recv__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v2.NextSequenceRecvData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for PacketAcknowledgementData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.path.is_empty() {
+            len += 1;
+        }
+        if !self.acknowledgement.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.lightclients.solomachine.v2.PacketAcknowledgementData",
+            len,
+        )?;
+        if !self.path.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
+        }
+        if !self.acknowledgement.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "acknowledgement",
+                pbjson::private::base64::encode(&self.acknowledgement).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for PacketAcknowledgementData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["path", "acknowledgement"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Path,
+            Acknowledgement,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "path" => Ok(GeneratedField::Path),
+                            "acknowledgement" => Ok(GeneratedField::Acknowledgement),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PacketAcknowledgementData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter
+                    .write_str("struct ibc.lightclients.solomachine.v2.PacketAcknowledgementData")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<PacketAcknowledgementData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut path__ = None;
+                let mut acknowledgement__ = 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::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Acknowledgement => {
+                            if acknowledgement__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("acknowledgement"));
+                            }
+                            acknowledgement__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(PacketAcknowledgementData {
+                    path: path__.unwrap_or_default(),
+                    acknowledgement: acknowledgement__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v2.PacketAcknowledgementData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for PacketCommitmentData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.path.is_empty() {
+            len += 1;
+        }
+        if !self.commitment.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer
+            .serialize_struct("ibc.lightclients.solomachine.v2.PacketCommitmentData", len)?;
+        if !self.path.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
+        }
+        if !self.commitment.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "commitment",
+                pbjson::private::base64::encode(&self.commitment).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for PacketCommitmentData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["path", "commitment"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Path,
+            Commitment,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "path" => Ok(GeneratedField::Path),
+                            "commitment" => Ok(GeneratedField::Commitment),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PacketCommitmentData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v2.PacketCommitmentData")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<PacketCommitmentData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut path__ = None;
+                let mut commitment__ = 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::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Commitment => {
+                            if commitment__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("commitment"));
+                            }
+                            commitment__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(PacketCommitmentData {
+                    path: path__.unwrap_or_default(),
+                    commitment: commitment__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v2.PacketCommitmentData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for PacketReceiptAbsenceData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.path.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.lightclients.solomachine.v2.PacketReceiptAbsenceData",
+            len,
+        )?;
+        if !self.path.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for PacketReceiptAbsenceData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["path"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Path,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "path" => Ok(GeneratedField::Path),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PacketReceiptAbsenceData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter
+                    .write_str("struct ibc.lightclients.solomachine.v2.PacketReceiptAbsenceData")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<PacketReceiptAbsenceData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut path__ = 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::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(PacketReceiptAbsenceData {
+                    path: path__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v2.PacketReceiptAbsenceData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for SignBytes {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.sequence != 0 {
+            len += 1;
+        }
+        if self.timestamp != 0 {
+            len += 1;
+        }
+        if !self.diversifier.is_empty() {
+            len += 1;
+        }
+        if self.data_type != 0 {
+            len += 1;
+        }
+        if !self.data.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.solomachine.v2.SignBytes", len)?;
+        if self.sequence != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("sequence", ToString::to_string(&self.sequence).as_str())?;
+        }
+        if self.timestamp != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("timestamp", ToString::to_string(&self.timestamp).as_str())?;
+        }
+        if !self.diversifier.is_empty() {
+            struct_ser.serialize_field("diversifier", &self.diversifier)?;
+        }
+        if self.data_type != 0 {
+            let v = DataType::try_from(self.data_type).map_err(|_| {
+                serde::ser::Error::custom(format!("Invalid variant {}", self.data_type))
+            })?;
+            struct_ser.serialize_field("dataType", &v)?;
+        }
+        if !self.data.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for SignBytes {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "sequence",
+            "timestamp",
+            "diversifier",
+            "data_type",
+            "dataType",
+            "data",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Sequence,
+            Timestamp,
+            Diversifier,
+            DataType,
+            Data,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "sequence" => Ok(GeneratedField::Sequence),
+                            "timestamp" => Ok(GeneratedField::Timestamp),
+                            "diversifier" => Ok(GeneratedField::Diversifier),
+                            "dataType" | "data_type" => Ok(GeneratedField::DataType),
+                            "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 = SignBytes;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v2.SignBytes")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SignBytes, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut sequence__ = None;
+                let mut timestamp__ = None;
+                let mut diversifier__ = None;
+                let mut data_type__ = None;
+                let mut data__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Sequence => {
+                            if sequence__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sequence"));
+                            }
+                            sequence__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Timestamp => {
+                            if timestamp__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timestamp"));
+                            }
+                            timestamp__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Diversifier => {
+                            if diversifier__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("diversifier"));
+                            }
+                            diversifier__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::DataType => {
+                            if data_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("dataType"));
+                            }
+                            data_type__ = Some(map_.next_value::<DataType>()? as i32);
+                        }
+                        GeneratedField::Data => {
+                            if data__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("data"));
+                            }
+                            data__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(SignBytes {
+                    sequence: sequence__.unwrap_or_default(),
+                    timestamp: timestamp__.unwrap_or_default(),
+                    diversifier: diversifier__.unwrap_or_default(),
+                    data_type: data_type__.unwrap_or_default(),
+                    data: data__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v2.SignBytes",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for SignatureAndData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.signature.is_empty() {
+            len += 1;
+        }
+        if self.data_type != 0 {
+            len += 1;
+        }
+        if !self.data.is_empty() {
+            len += 1;
+        }
+        if self.timestamp != 0 {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.solomachine.v2.SignatureAndData", len)?;
+        if !self.signature.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "signature",
+                pbjson::private::base64::encode(&self.signature).as_str(),
+            )?;
+        }
+        if self.data_type != 0 {
+            let v = DataType::try_from(self.data_type).map_err(|_| {
+                serde::ser::Error::custom(format!("Invalid variant {}", self.data_type))
+            })?;
+            struct_ser.serialize_field("dataType", &v)?;
+        }
+        if !self.data.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?;
+        }
+        if self.timestamp != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("timestamp", ToString::to_string(&self.timestamp).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for SignatureAndData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["signature", "data_type", "dataType", "data", "timestamp"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Signature,
+            DataType,
+            Data,
+            Timestamp,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "signature" => Ok(GeneratedField::Signature),
+                            "dataType" | "data_type" => Ok(GeneratedField::DataType),
+                            "data" => Ok(GeneratedField::Data),
+                            "timestamp" => Ok(GeneratedField::Timestamp),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = SignatureAndData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.solomachine.v2.SignatureAndData")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SignatureAndData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut signature__ = None;
+                let mut data_type__ = None;
+                let mut data__ = None;
+                let mut timestamp__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Signature => {
+                            if signature__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signature"));
+                            }
+                            signature__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::DataType => {
+                            if data_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("dataType"));
+                            }
+                            data_type__ = Some(map_.next_value::<DataType>()? as i32);
+                        }
+                        GeneratedField::Data => {
+                            if data__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("data"));
+                            }
+                            data__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Timestamp => {
+                            if timestamp__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timestamp"));
+                            }
+                            timestamp__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(SignatureAndData {
+                    signature: signature__.unwrap_or_default(),
+                    data_type: data_type__.unwrap_or_default(),
+                    data: data__.unwrap_or_default(),
+                    timestamp: timestamp__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v2.SignatureAndData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for TimestampedSignatureData {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.signature_data.is_empty() {
+            len += 1;
+        }
+        if self.timestamp != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct(
+            "ibc.lightclients.solomachine.v2.TimestampedSignatureData",
+            len,
+        )?;
+        if !self.signature_data.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "signatureData",
+                pbjson::private::base64::encode(&self.signature_data).as_str(),
+            )?;
+        }
+        if self.timestamp != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("timestamp", ToString::to_string(&self.timestamp).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for TimestampedSignatureData {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["signature_data", "signatureData", "timestamp"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            SignatureData,
+            Timestamp,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "signatureData" | "signature_data" => Ok(GeneratedField::SignatureData),
+                            "timestamp" => Ok(GeneratedField::Timestamp),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = TimestampedSignatureData;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter
+                    .write_str("struct ibc.lightclients.solomachine.v2.TimestampedSignatureData")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<TimestampedSignatureData, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut signature_data__ = None;
+                let mut timestamp__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::SignatureData => {
+                            if signature_data__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signatureData"));
+                            }
+                            signature_data__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Timestamp => {
+                            if timestamp__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timestamp"));
+                            }
+                            timestamp__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(TimestampedSignatureData {
+                    signature_data: signature_data__.unwrap_or_default(),
+                    timestamp: timestamp__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.solomachine.v2.TimestampedSignatureData",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.tendermint.v1.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.tendermint.v1.rs
index 910ecb22..5722b04a 100644
--- a/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.tendermint.v1.rs
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.tendermint.v1.rs
@@ -1,4 +1,4 @@
-// This file is @generated by prost-build.
+// @generated
 /// ClientState from Tendermint tracks the current validator set, latest height,
 /// and a possible frozen height.
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -45,16 +45,6 @@ pub struct ClientState {
     #[prost(bool, tag = "11")]
     pub allow_update_after_misbehaviour: bool,
 }
-impl ::prost::Name for ClientState {
-    const NAME: &'static str = "ClientState";
-    const PACKAGE: &'static str = "ibc.lightclients.tendermint.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.tendermint.v1.ClientState".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.tendermint.v1.ClientState".into()
-    }
-}
 /// ConsensusState defines the consensus state from Tendermint.
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -69,16 +59,6 @@ pub struct ConsensusState {
     #[prost(bytes = "vec", tag = "3")]
     pub next_validators_hash: ::prost::alloc::vec::Vec<u8>,
 }
-impl ::prost::Name for ConsensusState {
-    const NAME: &'static str = "ConsensusState";
-    const PACKAGE: &'static str = "ibc.lightclients.tendermint.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.tendermint.v1.ConsensusState".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.tendermint.v1.ConsensusState".into()
-    }
-}
 /// Misbehaviour is a wrapper over two conflicting Headers
 /// that implements Misbehaviour interface expected by ICS-02
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -91,16 +71,6 @@ pub struct Misbehaviour {
     #[prost(message, optional, tag = "3")]
     pub header_2: ::core::option::Option<Header>,
 }
-impl ::prost::Name for Misbehaviour {
-    const NAME: &'static str = "Misbehaviour";
-    const PACKAGE: &'static str = "ibc.lightclients.tendermint.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.tendermint.v1.Misbehaviour".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.tendermint.v1.Misbehaviour".into()
-    }
-}
 /// Header defines the Tendermint client consensus Header.
 /// It encapsulates all the information necessary to update from a trusted
 /// Tendermint ConsensusState. The inclusion of TrustedHeight and
@@ -117,41 +87,23 @@ impl ::prost::Name for Misbehaviour {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Header {
     #[prost(message, optional, tag = "1")]
-    pub signed_header: ::core::option::Option<::tendermint_proto::types::SignedHeader>,
+    pub signed_header: ::core::option::Option<tendermint_proto::types::SignedHeader>,
     #[prost(message, optional, tag = "2")]
-    pub validator_set: ::core::option::Option<::tendermint_proto::types::ValidatorSet>,
+    pub validator_set: ::core::option::Option<tendermint_proto::types::ValidatorSet>,
     #[prost(message, optional, tag = "3")]
     pub trusted_height: ::core::option::Option<super::super::super::core::client::v1::Height>,
     #[prost(message, optional, tag = "4")]
-    pub trusted_validators: ::core::option::Option<::tendermint_proto::types::ValidatorSet>,
-}
-impl ::prost::Name for Header {
-    const NAME: &'static str = "Header";
-    const PACKAGE: &'static str = "ibc.lightclients.tendermint.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.tendermint.v1.Header".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.tendermint.v1.Header".into()
-    }
+    pub trusted_validators: ::core::option::Option<tendermint_proto::types::ValidatorSet>,
 }
 /// Fraction defines the protobuf message type for tmmath.Fraction that only
 /// supports positive values.
 #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Fraction {
     #[prost(uint64, tag = "1")]
     pub numerator: u64,
     #[prost(uint64, tag = "2")]
     pub denominator: u64,
 }
-impl ::prost::Name for Fraction {
-    const NAME: &'static str = "Fraction";
-    const PACKAGE: &'static str = "ibc.lightclients.tendermint.v1";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ibc.lightclients.tendermint.v1.Fraction".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ibc.lightclients.tendermint.v1.Fraction".into()
-    }
-}
+include!("ibc.lightclients.tendermint.v1.serde.rs");
+// @@protoc_insertion_point(module)
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.tendermint.v1.serde.rs b/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.tendermint.v1.serde.rs
new file mode 100644
index 00000000..19439be4
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ibc.lightclients.tendermint.v1.serde.rs
@@ -0,0 +1,877 @@
+// @generated
+#[cfg(feature = "serde")]
+impl serde::Serialize for ClientState {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.chain_id.is_empty() {
+            len += 1;
+        }
+        if self.trust_level.is_some() {
+            len += 1;
+        }
+        if self.trusting_period.is_some() {
+            len += 1;
+        }
+        if self.unbonding_period.is_some() {
+            len += 1;
+        }
+        if self.max_clock_drift.is_some() {
+            len += 1;
+        }
+        if self.frozen_height.is_some() {
+            len += 1;
+        }
+        if self.latest_height.is_some() {
+            len += 1;
+        }
+        if !self.proof_specs.is_empty() {
+            len += 1;
+        }
+        if !self.upgrade_path.is_empty() {
+            len += 1;
+        }
+        if self.allow_update_after_expiry {
+            len += 1;
+        }
+        if self.allow_update_after_misbehaviour {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.tendermint.v1.ClientState", len)?;
+        if !self.chain_id.is_empty() {
+            struct_ser.serialize_field("chainId", &self.chain_id)?;
+        }
+        if let Some(v) = self.trust_level.as_ref() {
+            struct_ser.serialize_field("trustLevel", v)?;
+        }
+        if let Some(v) = self.trusting_period.as_ref() {
+            struct_ser.serialize_field("trustingPeriod", v)?;
+        }
+        if let Some(v) = self.unbonding_period.as_ref() {
+            struct_ser.serialize_field("unbondingPeriod", v)?;
+        }
+        if let Some(v) = self.max_clock_drift.as_ref() {
+            struct_ser.serialize_field("maxClockDrift", v)?;
+        }
+        if let Some(v) = self.frozen_height.as_ref() {
+            struct_ser.serialize_field("frozenHeight", v)?;
+        }
+        if let Some(v) = self.latest_height.as_ref() {
+            struct_ser.serialize_field("latestHeight", v)?;
+        }
+        if !self.proof_specs.is_empty() {
+            struct_ser.serialize_field("proofSpecs", &self.proof_specs)?;
+        }
+        if !self.upgrade_path.is_empty() {
+            struct_ser.serialize_field("upgradePath", &self.upgrade_path)?;
+        }
+        if self.allow_update_after_expiry {
+            struct_ser
+                .serialize_field("allowUpdateAfterExpiry", &self.allow_update_after_expiry)?;
+        }
+        if self.allow_update_after_misbehaviour {
+            struct_ser.serialize_field(
+                "allowUpdateAfterMisbehaviour",
+                &self.allow_update_after_misbehaviour,
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ClientState {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "chain_id",
+            "chainId",
+            "trust_level",
+            "trustLevel",
+            "trusting_period",
+            "trustingPeriod",
+            "unbonding_period",
+            "unbondingPeriod",
+            "max_clock_drift",
+            "maxClockDrift",
+            "frozen_height",
+            "frozenHeight",
+            "latest_height",
+            "latestHeight",
+            "proof_specs",
+            "proofSpecs",
+            "upgrade_path",
+            "upgradePath",
+            "allow_update_after_expiry",
+            "allowUpdateAfterExpiry",
+            "allow_update_after_misbehaviour",
+            "allowUpdateAfterMisbehaviour",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ChainId,
+            TrustLevel,
+            TrustingPeriod,
+            UnbondingPeriod,
+            MaxClockDrift,
+            FrozenHeight,
+            LatestHeight,
+            ProofSpecs,
+            UpgradePath,
+            AllowUpdateAfterExpiry,
+            AllowUpdateAfterMisbehaviour,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "chainId" | "chain_id" => Ok(GeneratedField::ChainId),
+                            "trustLevel" | "trust_level" => Ok(GeneratedField::TrustLevel),
+                            "trustingPeriod" | "trusting_period" => {
+                                Ok(GeneratedField::TrustingPeriod)
+                            }
+                            "unbondingPeriod" | "unbonding_period" => {
+                                Ok(GeneratedField::UnbondingPeriod)
+                            }
+                            "maxClockDrift" | "max_clock_drift" => {
+                                Ok(GeneratedField::MaxClockDrift)
+                            }
+                            "frozenHeight" | "frozen_height" => Ok(GeneratedField::FrozenHeight),
+                            "latestHeight" | "latest_height" => Ok(GeneratedField::LatestHeight),
+                            "proofSpecs" | "proof_specs" => Ok(GeneratedField::ProofSpecs),
+                            "upgradePath" | "upgrade_path" => Ok(GeneratedField::UpgradePath),
+                            "allowUpdateAfterExpiry" | "allow_update_after_expiry" => {
+                                Ok(GeneratedField::AllowUpdateAfterExpiry)
+                            }
+                            "allowUpdateAfterMisbehaviour" | "allow_update_after_misbehaviour" => {
+                                Ok(GeneratedField::AllowUpdateAfterMisbehaviour)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ClientState;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.tendermint.v1.ClientState")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClientState, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut chain_id__ = None;
+                let mut trust_level__ = None;
+                let mut trusting_period__ = None;
+                let mut unbonding_period__ = None;
+                let mut max_clock_drift__ = None;
+                let mut frozen_height__ = None;
+                let mut latest_height__ = None;
+                let mut proof_specs__ = None;
+                let mut upgrade_path__ = None;
+                let mut allow_update_after_expiry__ = None;
+                let mut allow_update_after_misbehaviour__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ChainId => {
+                            if chain_id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("chainId"));
+                            }
+                            chain_id__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::TrustLevel => {
+                            if trust_level__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("trustLevel"));
+                            }
+                            trust_level__ = map_.next_value()?;
+                        }
+                        GeneratedField::TrustingPeriod => {
+                            if trusting_period__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("trustingPeriod"));
+                            }
+                            trusting_period__ = map_.next_value()?;
+                        }
+                        GeneratedField::UnbondingPeriod => {
+                            if unbonding_period__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("unbondingPeriod"));
+                            }
+                            unbonding_period__ = map_.next_value()?;
+                        }
+                        GeneratedField::MaxClockDrift => {
+                            if max_clock_drift__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("maxClockDrift"));
+                            }
+                            max_clock_drift__ = map_.next_value()?;
+                        }
+                        GeneratedField::FrozenHeight => {
+                            if frozen_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("frozenHeight"));
+                            }
+                            frozen_height__ = map_.next_value()?;
+                        }
+                        GeneratedField::LatestHeight => {
+                            if latest_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("latestHeight"));
+                            }
+                            latest_height__ = map_.next_value()?;
+                        }
+                        GeneratedField::ProofSpecs => {
+                            if proof_specs__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("proofSpecs"));
+                            }
+                            proof_specs__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::UpgradePath => {
+                            if upgrade_path__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("upgradePath"));
+                            }
+                            upgrade_path__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::AllowUpdateAfterExpiry => {
+                            if allow_update_after_expiry__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "allowUpdateAfterExpiry",
+                                ));
+                            }
+                            allow_update_after_expiry__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::AllowUpdateAfterMisbehaviour => {
+                            if allow_update_after_misbehaviour__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "allowUpdateAfterMisbehaviour",
+                                ));
+                            }
+                            allow_update_after_misbehaviour__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(ClientState {
+                    chain_id: chain_id__.unwrap_or_default(),
+                    trust_level: trust_level__,
+                    trusting_period: trusting_period__,
+                    unbonding_period: unbonding_period__,
+                    max_clock_drift: max_clock_drift__,
+                    frozen_height: frozen_height__,
+                    latest_height: latest_height__,
+                    proof_specs: proof_specs__.unwrap_or_default(),
+                    upgrade_path: upgrade_path__.unwrap_or_default(),
+                    allow_update_after_expiry: allow_update_after_expiry__.unwrap_or_default(),
+                    allow_update_after_misbehaviour: allow_update_after_misbehaviour__
+                        .unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.tendermint.v1.ClientState",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for ConsensusState {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.timestamp.is_some() {
+            len += 1;
+        }
+        if self.root.is_some() {
+            len += 1;
+        }
+        if !self.next_validators_hash.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.tendermint.v1.ConsensusState", len)?;
+        if let Some(v) = self.timestamp.as_ref() {
+            struct_ser.serialize_field("timestamp", v)?;
+        }
+        if let Some(v) = self.root.as_ref() {
+            struct_ser.serialize_field("root", v)?;
+        }
+        if !self.next_validators_hash.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "nextValidatorsHash",
+                pbjson::private::base64::encode(&self.next_validators_hash).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ConsensusState {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "timestamp",
+            "root",
+            "next_validators_hash",
+            "nextValidatorsHash",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Timestamp,
+            Root,
+            NextValidatorsHash,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "timestamp" => Ok(GeneratedField::Timestamp),
+                            "root" => Ok(GeneratedField::Root),
+                            "nextValidatorsHash" | "next_validators_hash" => {
+                                Ok(GeneratedField::NextValidatorsHash)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ConsensusState;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.tendermint.v1.ConsensusState")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConsensusState, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut timestamp__ = None;
+                let mut root__ = None;
+                let mut next_validators_hash__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Timestamp => {
+                            if timestamp__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timestamp"));
+                            }
+                            timestamp__ = map_.next_value()?;
+                        }
+                        GeneratedField::Root => {
+                            if root__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("root"));
+                            }
+                            root__ = map_.next_value()?;
+                        }
+                        GeneratedField::NextValidatorsHash => {
+                            if next_validators_hash__.is_some() {
+                                return Err(serde::de::Error::duplicate_field(
+                                    "nextValidatorsHash",
+                                ));
+                            }
+                            next_validators_hash__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(ConsensusState {
+                    timestamp: timestamp__,
+                    root: root__,
+                    next_validators_hash: next_validators_hash__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.tendermint.v1.ConsensusState",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Fraction {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.numerator != 0 {
+            len += 1;
+        }
+        if self.denominator != 0 {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.tendermint.v1.Fraction", len)?;
+        if self.numerator != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("numerator", ToString::to_string(&self.numerator).as_str())?;
+        }
+        if self.denominator != 0 {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "denominator",
+                ToString::to_string(&self.denominator).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Fraction {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["numerator", "denominator"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Numerator,
+            Denominator,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "numerator" => Ok(GeneratedField::Numerator),
+                            "denominator" => Ok(GeneratedField::Denominator),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Fraction;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.tendermint.v1.Fraction")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Fraction, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut numerator__ = None;
+                let mut denominator__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Numerator => {
+                            if numerator__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("numerator"));
+                            }
+                            numerator__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Denominator => {
+                            if denominator__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("denominator"));
+                            }
+                            denominator__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(Fraction {
+                    numerator: numerator__.unwrap_or_default(),
+                    denominator: denominator__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.tendermint.v1.Fraction",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Header {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.signed_header.is_some() {
+            len += 1;
+        }
+        if self.validator_set.is_some() {
+            len += 1;
+        }
+        if self.trusted_height.is_some() {
+            len += 1;
+        }
+        if self.trusted_validators.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.tendermint.v1.Header", len)?;
+        if let Some(v) = self.signed_header.as_ref() {
+            struct_ser.serialize_field("signedHeader", v)?;
+        }
+        if let Some(v) = self.validator_set.as_ref() {
+            struct_ser.serialize_field("validatorSet", v)?;
+        }
+        if let Some(v) = self.trusted_height.as_ref() {
+            struct_ser.serialize_field("trustedHeight", v)?;
+        }
+        if let Some(v) = self.trusted_validators.as_ref() {
+            struct_ser.serialize_field("trustedValidators", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Header {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "signed_header",
+            "signedHeader",
+            "validator_set",
+            "validatorSet",
+            "trusted_height",
+            "trustedHeight",
+            "trusted_validators",
+            "trustedValidators",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            SignedHeader,
+            ValidatorSet,
+            TrustedHeight,
+            TrustedValidators,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "signedHeader" | "signed_header" => Ok(GeneratedField::SignedHeader),
+                            "validatorSet" | "validator_set" => Ok(GeneratedField::ValidatorSet),
+                            "trustedHeight" | "trusted_height" => Ok(GeneratedField::TrustedHeight),
+                            "trustedValidators" | "trusted_validators" => {
+                                Ok(GeneratedField::TrustedValidators)
+                            }
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Header;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.tendermint.v1.Header")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Header, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut signed_header__ = None;
+                let mut validator_set__ = None;
+                let mut trusted_height__ = None;
+                let mut trusted_validators__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::SignedHeader => {
+                            if signed_header__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("signedHeader"));
+                            }
+                            signed_header__ = map_.next_value()?;
+                        }
+                        GeneratedField::ValidatorSet => {
+                            if validator_set__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("validatorSet"));
+                            }
+                            validator_set__ = map_.next_value()?;
+                        }
+                        GeneratedField::TrustedHeight => {
+                            if trusted_height__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("trustedHeight"));
+                            }
+                            trusted_height__ = map_.next_value()?;
+                        }
+                        GeneratedField::TrustedValidators => {
+                            if trusted_validators__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("trustedValidators"));
+                            }
+                            trusted_validators__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(Header {
+                    signed_header: signed_header__,
+                    validator_set: validator_set__,
+                    trusted_height: trusted_height__,
+                    trusted_validators: trusted_validators__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.tendermint.v1.Header",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for Misbehaviour {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.client_id.is_empty() {
+            len += 1;
+        }
+        if self.header_1.is_some() {
+            len += 1;
+        }
+        if self.header_2.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ibc.lightclients.tendermint.v1.Misbehaviour", len)?;
+        if !self.client_id.is_empty() {
+            struct_ser.serialize_field("clientId", &self.client_id)?;
+        }
+        if let Some(v) = self.header_1.as_ref() {
+            struct_ser.serialize_field("header1", v)?;
+        }
+        if let Some(v) = self.header_2.as_ref() {
+            struct_ser.serialize_field("header2", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Misbehaviour {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "client_id",
+            "clientId",
+            "header_1",
+            "header1",
+            "header_2",
+            "header2",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ClientId,
+            Header1,
+            Header2,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "clientId" | "client_id" => Ok(GeneratedField::ClientId),
+                            "header1" | "header_1" => Ok(GeneratedField::Header1),
+                            "header2" | "header_2" => Ok(GeneratedField::Header2),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Misbehaviour;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ibc.lightclients.tendermint.v1.Misbehaviour")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Misbehaviour, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut client_id__ = None;
+                let mut header_1__ = None;
+                let mut header_2__ = 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::Header1 => {
+                            if header_1__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("header1"));
+                            }
+                            header_1__ = map_.next_value()?;
+                        }
+                        GeneratedField::Header2 => {
+                            if header_2__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("header2"));
+                            }
+                            header_2__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(Misbehaviour {
+                    client_id: client_id__.unwrap_or_default(),
+                    header_1: header_1__,
+                    header_2: header_2__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ibc.lightclients.tendermint.v1.Misbehaviour",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ics23.rs b/cosmos-sdk-proto/src/prost/ibc-go/ics23.rs
index 13a57d86..7a97b7ce 100644
--- a/cosmos-sdk-proto/src/prost/ibc-go/ics23.rs
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ics23.rs
@@ -1,4 +1,4 @@
-// This file is @generated by prost-build.
+// @generated
 /// *
 /// ExistenceProof takes a key and a value and a set of steps to perform on it.
 /// The result of peforming all these steps will provide a "root hash", which can
@@ -31,16 +31,6 @@ pub struct ExistenceProof {
     #[prost(message, repeated, tag = "4")]
     pub path: ::prost::alloc::vec::Vec<InnerOp>,
 }
-impl ::prost::Name for ExistenceProof {
-    const NAME: &'static str = "ExistenceProof";
-    const PACKAGE: &'static str = "ics23";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ics23.ExistenceProof".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ics23.ExistenceProof".into()
-    }
-}
 ///
 /// NonExistenceProof takes a proof of two neighbors, one left of the desired key,
 /// one right of the desired key. If both proofs are valid AND they are neighbors,
@@ -56,16 +46,6 @@ pub struct NonExistenceProof {
     #[prost(message, optional, tag = "3")]
     pub right: ::core::option::Option<ExistenceProof>,
 }
-impl ::prost::Name for NonExistenceProof {
-    const NAME: &'static str = "NonExistenceProof";
-    const PACKAGE: &'static str = "ics23";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ics23.NonExistenceProof".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ics23.NonExistenceProof".into()
-    }
-}
 ///
 /// CommitmentProof is either an ExistenceProof or a NonExistenceProof, or a Batch of such messages
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -89,16 +69,6 @@ pub mod commitment_proof {
         Compressed(super::CompressedBatchProof),
     }
 }
-impl ::prost::Name for CommitmentProof {
-    const NAME: &'static str = "CommitmentProof";
-    const PACKAGE: &'static str = "ics23";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ics23.CommitmentProof".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ics23.CommitmentProof".into()
-    }
-}
 /// *
 /// LeafOp represents the raw key-value data we wish to prove, and
 /// must be flexible to represent the internal transformation from
@@ -130,16 +100,6 @@ pub struct LeafOp {
     #[prost(bytes = "vec", tag = "5")]
     pub prefix: ::prost::alloc::vec::Vec<u8>,
 }
-impl ::prost::Name for LeafOp {
-    const NAME: &'static str = "LeafOp";
-    const PACKAGE: &'static str = "ics23";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ics23.LeafOp".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ics23.LeafOp".into()
-    }
-}
 /// *
 /// InnerOp represents a merkle-proof step that is not a leaf.
 /// It represents concatenating two children and hashing them to provide the next result.
@@ -166,16 +126,6 @@ pub struct InnerOp {
     #[prost(bytes = "vec", tag = "3")]
     pub suffix: ::prost::alloc::vec::Vec<u8>,
 }
-impl ::prost::Name for InnerOp {
-    const NAME: &'static str = "InnerOp";
-    const PACKAGE: &'static str = "ics23";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ics23.InnerOp".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ics23.InnerOp".into()
-    }
-}
 /// *
 /// ProofSpec defines what the expected parameters are for a given proof type.
 /// This can be stored in the client and used to validate any incoming proofs.
@@ -203,16 +153,6 @@ pub struct ProofSpec {
     #[prost(int32, tag = "4")]
     pub min_depth: i32,
 }
-impl ::prost::Name for ProofSpec {
-    const NAME: &'static str = "ProofSpec";
-    const PACKAGE: &'static str = "ics23";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ics23.ProofSpec".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ics23.ProofSpec".into()
-    }
-}
 ///
 /// InnerSpec contains all store-specific structure info to determine if two proofs from a
 /// given store are neighbors.
@@ -243,16 +183,6 @@ pub struct InnerSpec {
     #[prost(enumeration = "HashOp", tag = "6")]
     pub hash: i32,
 }
-impl ::prost::Name for InnerSpec {
-    const NAME: &'static str = "InnerSpec";
-    const PACKAGE: &'static str = "ics23";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ics23.InnerSpec".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ics23.InnerSpec".into()
-    }
-}
 ///
 /// BatchProof is a group of multiple proof types than can be compressed
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -261,16 +191,6 @@ pub struct BatchProof {
     #[prost(message, repeated, tag = "1")]
     pub entries: ::prost::alloc::vec::Vec<BatchEntry>,
 }
-impl ::prost::Name for BatchProof {
-    const NAME: &'static str = "BatchProof";
-    const PACKAGE: &'static str = "ics23";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ics23.BatchProof".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ics23.BatchProof".into()
-    }
-}
 /// Use BatchEntry not CommitmentProof, to avoid recursion
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -289,16 +209,8 @@ pub mod batch_entry {
         Nonexist(super::NonExistenceProof),
     }
 }
-impl ::prost::Name for BatchEntry {
-    const NAME: &'static str = "BatchEntry";
-    const PACKAGE: &'static str = "ics23";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ics23.BatchEntry".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ics23.BatchEntry".into()
-    }
-}
+// ***** all items here are compressed forms ******
+
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CompressedBatchProof {
@@ -307,16 +219,6 @@ pub struct CompressedBatchProof {
     #[prost(message, repeated, tag = "2")]
     pub lookup_inners: ::prost::alloc::vec::Vec<InnerOp>,
 }
-impl ::prost::Name for CompressedBatchProof {
-    const NAME: &'static str = "CompressedBatchProof";
-    const PACKAGE: &'static str = "ics23";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ics23.CompressedBatchProof".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ics23.CompressedBatchProof".into()
-    }
-}
 /// Use BatchEntry not CommitmentProof, to avoid recursion
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -335,16 +237,6 @@ pub mod compressed_batch_entry {
         Nonexist(super::CompressedNonExistenceProof),
     }
 }
-impl ::prost::Name for CompressedBatchEntry {
-    const NAME: &'static str = "CompressedBatchEntry";
-    const PACKAGE: &'static str = "ics23";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ics23.CompressedBatchEntry".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ics23.CompressedBatchEntry".into()
-    }
-}
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CompressedExistenceProof {
@@ -358,16 +250,6 @@ pub struct CompressedExistenceProof {
     #[prost(int32, repeated, tag = "4")]
     pub path: ::prost::alloc::vec::Vec<i32>,
 }
-impl ::prost::Name for CompressedExistenceProof {
-    const NAME: &'static str = "CompressedExistenceProof";
-    const PACKAGE: &'static str = "ics23";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ics23.CompressedExistenceProof".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ics23.CompressedExistenceProof".into()
-    }
-}
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CompressedNonExistenceProof {
@@ -379,16 +261,6 @@ pub struct CompressedNonExistenceProof {
     #[prost(message, optional, tag = "3")]
     pub right: ::core::option::Option<CompressedExistenceProof>,
 }
-impl ::prost::Name for CompressedNonExistenceProof {
-    const NAME: &'static str = "CompressedNonExistenceProof";
-    const PACKAGE: &'static str = "ics23";
-    fn full_name() -> ::prost::alloc::string::String {
-        "ics23.CompressedNonExistenceProof".into()
-    }
-    fn type_url() -> ::prost::alloc::string::String {
-        "/ics23.CompressedNonExistenceProof".into()
-    }
-}
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
 #[repr(i32)]
 pub enum HashOp {
@@ -493,3 +365,5 @@ impl LengthOp {
         }
     }
 }
+include!("ics23.serde.rs");
+// @@protoc_insertion_point(module)
diff --git a/cosmos-sdk-proto/src/prost/ibc-go/ics23.serde.rs b/cosmos-sdk-proto/src/prost/ibc-go/ics23.serde.rs
new file mode 100644
index 00000000..1e331637
--- /dev/null
+++ b/cosmos-sdk-proto/src/prost/ibc-go/ics23.serde.rs
@@ -0,0 +1,2047 @@
+// @generated
+#[cfg(feature = "serde")]
+impl serde::Serialize for BatchEntry {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.proof.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ics23.BatchEntry", len)?;
+        if let Some(v) = self.proof.as_ref() {
+            match v {
+                batch_entry::Proof::Exist(v) => {
+                    struct_ser.serialize_field("exist", v)?;
+                }
+                batch_entry::Proof::Nonexist(v) => {
+                    struct_ser.serialize_field("nonexist", v)?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for BatchEntry {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["exist", "nonexist"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Exist,
+            Nonexist,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "exist" => Ok(GeneratedField::Exist),
+                            "nonexist" => Ok(GeneratedField::Nonexist),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = BatchEntry;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ics23.BatchEntry")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchEntry, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut proof__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Exist => {
+                            if proof__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("exist"));
+                            }
+                            proof__ = map_
+                                .next_value::<::std::option::Option<_>>()?
+                                .map(batch_entry::Proof::Exist);
+                        }
+                        GeneratedField::Nonexist => {
+                            if proof__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("nonexist"));
+                            }
+                            proof__ = map_
+                                .next_value::<::std::option::Option<_>>()?
+                                .map(batch_entry::Proof::Nonexist);
+                        }
+                    }
+                }
+                Ok(BatchEntry { proof: proof__ })
+            }
+        }
+        deserializer.deserialize_struct("ics23.BatchEntry", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for BatchProof {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.entries.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ics23.BatchProof", len)?;
+        if !self.entries.is_empty() {
+            struct_ser.serialize_field("entries", &self.entries)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for BatchProof {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["entries"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Entries,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "entries" => Ok(GeneratedField::Entries),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = BatchProof;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ics23.BatchProof")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchProof, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut entries__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Entries => {
+                            if entries__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("entries"));
+                            }
+                            entries__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(BatchProof {
+                    entries: entries__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("ics23.BatchProof", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for CommitmentProof {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.proof.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ics23.CommitmentProof", len)?;
+        if let Some(v) = self.proof.as_ref() {
+            match v {
+                commitment_proof::Proof::Exist(v) => {
+                    struct_ser.serialize_field("exist", v)?;
+                }
+                commitment_proof::Proof::Nonexist(v) => {
+                    struct_ser.serialize_field("nonexist", v)?;
+                }
+                commitment_proof::Proof::Batch(v) => {
+                    struct_ser.serialize_field("batch", v)?;
+                }
+                commitment_proof::Proof::Compressed(v) => {
+                    struct_ser.serialize_field("compressed", v)?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for CommitmentProof {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["exist", "nonexist", "batch", "compressed"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Exist,
+            Nonexist,
+            Batch,
+            Compressed,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "exist" => Ok(GeneratedField::Exist),
+                            "nonexist" => Ok(GeneratedField::Nonexist),
+                            "batch" => Ok(GeneratedField::Batch),
+                            "compressed" => Ok(GeneratedField::Compressed),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = CommitmentProof;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ics23.CommitmentProof")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CommitmentProof, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut proof__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Exist => {
+                            if proof__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("exist"));
+                            }
+                            proof__ = map_
+                                .next_value::<::std::option::Option<_>>()?
+                                .map(commitment_proof::Proof::Exist);
+                        }
+                        GeneratedField::Nonexist => {
+                            if proof__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("nonexist"));
+                            }
+                            proof__ = map_
+                                .next_value::<::std::option::Option<_>>()?
+                                .map(commitment_proof::Proof::Nonexist);
+                        }
+                        GeneratedField::Batch => {
+                            if proof__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("batch"));
+                            }
+                            proof__ = map_
+                                .next_value::<::std::option::Option<_>>()?
+                                .map(commitment_proof::Proof::Batch);
+                        }
+                        GeneratedField::Compressed => {
+                            if proof__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("compressed"));
+                            }
+                            proof__ = map_
+                                .next_value::<::std::option::Option<_>>()?
+                                .map(commitment_proof::Proof::Compressed);
+                        }
+                    }
+                }
+                Ok(CommitmentProof { proof: proof__ })
+            }
+        }
+        deserializer.deserialize_struct("ics23.CommitmentProof", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for CompressedBatchEntry {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.proof.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ics23.CompressedBatchEntry", len)?;
+        if let Some(v) = self.proof.as_ref() {
+            match v {
+                compressed_batch_entry::Proof::Exist(v) => {
+                    struct_ser.serialize_field("exist", v)?;
+                }
+                compressed_batch_entry::Proof::Nonexist(v) => {
+                    struct_ser.serialize_field("nonexist", v)?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for CompressedBatchEntry {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["exist", "nonexist"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Exist,
+            Nonexist,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "exist" => Ok(GeneratedField::Exist),
+                            "nonexist" => Ok(GeneratedField::Nonexist),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = CompressedBatchEntry;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ics23.CompressedBatchEntry")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<CompressedBatchEntry, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut proof__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Exist => {
+                            if proof__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("exist"));
+                            }
+                            proof__ = map_
+                                .next_value::<::std::option::Option<_>>()?
+                                .map(compressed_batch_entry::Proof::Exist);
+                        }
+                        GeneratedField::Nonexist => {
+                            if proof__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("nonexist"));
+                            }
+                            proof__ = map_
+                                .next_value::<::std::option::Option<_>>()?
+                                .map(compressed_batch_entry::Proof::Nonexist);
+                        }
+                    }
+                }
+                Ok(CompressedBatchEntry { proof: proof__ })
+            }
+        }
+        deserializer.deserialize_struct("ics23.CompressedBatchEntry", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for CompressedBatchProof {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.entries.is_empty() {
+            len += 1;
+        }
+        if !self.lookup_inners.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ics23.CompressedBatchProof", len)?;
+        if !self.entries.is_empty() {
+            struct_ser.serialize_field("entries", &self.entries)?;
+        }
+        if !self.lookup_inners.is_empty() {
+            struct_ser.serialize_field("lookupInners", &self.lookup_inners)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for CompressedBatchProof {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["entries", "lookup_inners", "lookupInners"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Entries,
+            LookupInners,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "entries" => Ok(GeneratedField::Entries),
+                            "lookupInners" | "lookup_inners" => Ok(GeneratedField::LookupInners),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = CompressedBatchProof;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ics23.CompressedBatchProof")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<CompressedBatchProof, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut entries__ = None;
+                let mut lookup_inners__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Entries => {
+                            if entries__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("entries"));
+                            }
+                            entries__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::LookupInners => {
+                            if lookup_inners__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("lookupInners"));
+                            }
+                            lookup_inners__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(CompressedBatchProof {
+                    entries: entries__.unwrap_or_default(),
+                    lookup_inners: lookup_inners__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("ics23.CompressedBatchProof", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for CompressedExistenceProof {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.key.is_empty() {
+            len += 1;
+        }
+        if !self.value.is_empty() {
+            len += 1;
+        }
+        if self.leaf.is_some() {
+            len += 1;
+        }
+        if !self.path.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ics23.CompressedExistenceProof", len)?;
+        if !self.key.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?;
+        }
+        if !self.value.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "value",
+                pbjson::private::base64::encode(&self.value).as_str(),
+            )?;
+        }
+        if let Some(v) = self.leaf.as_ref() {
+            struct_ser.serialize_field("leaf", v)?;
+        }
+        if !self.path.is_empty() {
+            struct_ser.serialize_field("path", &self.path)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for CompressedExistenceProof {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["key", "value", "leaf", "path"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Key,
+            Value,
+            Leaf,
+            Path,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "key" => Ok(GeneratedField::Key),
+                            "value" => Ok(GeneratedField::Value),
+                            "leaf" => Ok(GeneratedField::Leaf),
+                            "path" => Ok(GeneratedField::Path),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = CompressedExistenceProof;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ics23.CompressedExistenceProof")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<CompressedExistenceProof, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut key__ = None;
+                let mut value__ = None;
+                let mut leaf__ = None;
+                let mut path__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Key => {
+                            if key__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("key"));
+                            }
+                            key__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("value"));
+                            }
+                            value__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Leaf => {
+                            if leaf__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("leaf"));
+                            }
+                            leaf__ = map_.next_value()?;
+                        }
+                        GeneratedField::Path => {
+                            if path__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("path"));
+                            }
+                            path__ = Some(
+                                map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
+                                    .into_iter()
+                                    .map(|x| x.0)
+                                    .collect(),
+                            );
+                        }
+                    }
+                }
+                Ok(CompressedExistenceProof {
+                    key: key__.unwrap_or_default(),
+                    value: value__.unwrap_or_default(),
+                    leaf: leaf__,
+                    path: path__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("ics23.CompressedExistenceProof", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for CompressedNonExistenceProof {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.key.is_empty() {
+            len += 1;
+        }
+        if self.left.is_some() {
+            len += 1;
+        }
+        if self.right.is_some() {
+            len += 1;
+        }
+        let mut struct_ser =
+            serializer.serialize_struct("ics23.CompressedNonExistenceProof", len)?;
+        if !self.key.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?;
+        }
+        if let Some(v) = self.left.as_ref() {
+            struct_ser.serialize_field("left", v)?;
+        }
+        if let Some(v) = self.right.as_ref() {
+            struct_ser.serialize_field("right", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for CompressedNonExistenceProof {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["key", "left", "right"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Key,
+            Left,
+            Right,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "key" => Ok(GeneratedField::Key),
+                            "left" => Ok(GeneratedField::Left),
+                            "right" => Ok(GeneratedField::Right),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = CompressedNonExistenceProof;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ics23.CompressedNonExistenceProof")
+            }
+
+            fn visit_map<V>(
+                self,
+                mut map_: V,
+            ) -> std::result::Result<CompressedNonExistenceProof, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut key__ = None;
+                let mut left__ = None;
+                let mut right__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Key => {
+                            if key__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("key"));
+                            }
+                            key__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Left => {
+                            if left__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("left"));
+                            }
+                            left__ = map_.next_value()?;
+                        }
+                        GeneratedField::Right => {
+                            if right__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("right"));
+                            }
+                            right__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(CompressedNonExistenceProof {
+                    key: key__.unwrap_or_default(),
+                    left: left__,
+                    right: right__,
+                })
+            }
+        }
+        deserializer.deserialize_struct(
+            "ics23.CompressedNonExistenceProof",
+            FIELDS,
+            GeneratedVisitor,
+        )
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for ExistenceProof {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.key.is_empty() {
+            len += 1;
+        }
+        if !self.value.is_empty() {
+            len += 1;
+        }
+        if self.leaf.is_some() {
+            len += 1;
+        }
+        if !self.path.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ics23.ExistenceProof", len)?;
+        if !self.key.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?;
+        }
+        if !self.value.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "value",
+                pbjson::private::base64::encode(&self.value).as_str(),
+            )?;
+        }
+        if let Some(v) = self.leaf.as_ref() {
+            struct_ser.serialize_field("leaf", v)?;
+        }
+        if !self.path.is_empty() {
+            struct_ser.serialize_field("path", &self.path)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ExistenceProof {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["key", "value", "leaf", "path"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Key,
+            Value,
+            Leaf,
+            Path,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "key" => Ok(GeneratedField::Key),
+                            "value" => Ok(GeneratedField::Value),
+                            "leaf" => Ok(GeneratedField::Leaf),
+                            "path" => Ok(GeneratedField::Path),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ExistenceProof;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ics23.ExistenceProof")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExistenceProof, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut key__ = None;
+                let mut value__ = None;
+                let mut leaf__ = None;
+                let mut path__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Key => {
+                            if key__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("key"));
+                            }
+                            key__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("value"));
+                            }
+                            value__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Leaf => {
+                            if leaf__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("leaf"));
+                            }
+                            leaf__ = map_.next_value()?;
+                        }
+                        GeneratedField::Path => {
+                            if path__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("path"));
+                            }
+                            path__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(ExistenceProof {
+                    key: key__.unwrap_or_default(),
+                    value: value__.unwrap_or_default(),
+                    leaf: leaf__,
+                    path: path__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("ics23.ExistenceProof", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for HashOp {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::NoHash => "NO_HASH",
+            Self::Sha256 => "SHA256",
+            Self::Sha512 => "SHA512",
+            Self::Keccak => "KECCAK",
+            Self::Ripemd160 => "RIPEMD160",
+            Self::Bitcoin => "BITCOIN",
+            Self::Sha512256 => "SHA512_256",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for HashOp {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "NO_HASH",
+            "SHA256",
+            "SHA512",
+            "KECCAK",
+            "RIPEMD160",
+            "BITCOIN",
+            "SHA512_256",
+        ];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = HashOp;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                i32::try_from(v)
+                    .ok()
+                    .and_then(|x| x.try_into().ok())
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                i32::try_from(v)
+                    .ok()
+                    .and_then(|x| x.try_into().ok())
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "NO_HASH" => Ok(HashOp::NoHash),
+                    "SHA256" => Ok(HashOp::Sha256),
+                    "SHA512" => Ok(HashOp::Sha512),
+                    "KECCAK" => Ok(HashOp::Keccak),
+                    "RIPEMD160" => Ok(HashOp::Ripemd160),
+                    "BITCOIN" => Ok(HashOp::Bitcoin),
+                    "SHA512_256" => Ok(HashOp::Sha512256),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for InnerOp {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.hash != 0 {
+            len += 1;
+        }
+        if !self.prefix.is_empty() {
+            len += 1;
+        }
+        if !self.suffix.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ics23.InnerOp", len)?;
+        if self.hash != 0 {
+            let v = HashOp::try_from(self.hash)
+                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.hash)))?;
+            struct_ser.serialize_field("hash", &v)?;
+        }
+        if !self.prefix.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "prefix",
+                pbjson::private::base64::encode(&self.prefix).as_str(),
+            )?;
+        }
+        if !self.suffix.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "suffix",
+                pbjson::private::base64::encode(&self.suffix).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for InnerOp {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["hash", "prefix", "suffix"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Hash,
+            Prefix,
+            Suffix,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "hash" => Ok(GeneratedField::Hash),
+                            "prefix" => Ok(GeneratedField::Prefix),
+                            "suffix" => Ok(GeneratedField::Suffix),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = InnerOp;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ics23.InnerOp")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<InnerOp, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut hash__ = None;
+                let mut prefix__ = None;
+                let mut suffix__ = 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::<HashOp>()? as i32);
+                        }
+                        GeneratedField::Prefix => {
+                            if prefix__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("prefix"));
+                            }
+                            prefix__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Suffix => {
+                            if suffix__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("suffix"));
+                            }
+                            suffix__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(InnerOp {
+                    hash: hash__.unwrap_or_default(),
+                    prefix: prefix__.unwrap_or_default(),
+                    suffix: suffix__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("ics23.InnerOp", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for InnerSpec {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.child_order.is_empty() {
+            len += 1;
+        }
+        if self.child_size != 0 {
+            len += 1;
+        }
+        if self.min_prefix_length != 0 {
+            len += 1;
+        }
+        if self.max_prefix_length != 0 {
+            len += 1;
+        }
+        if !self.empty_child.is_empty() {
+            len += 1;
+        }
+        if self.hash != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ics23.InnerSpec", len)?;
+        if !self.child_order.is_empty() {
+            struct_ser.serialize_field("childOrder", &self.child_order)?;
+        }
+        if self.child_size != 0 {
+            struct_ser.serialize_field("childSize", &self.child_size)?;
+        }
+        if self.min_prefix_length != 0 {
+            struct_ser.serialize_field("minPrefixLength", &self.min_prefix_length)?;
+        }
+        if self.max_prefix_length != 0 {
+            struct_ser.serialize_field("maxPrefixLength", &self.max_prefix_length)?;
+        }
+        if !self.empty_child.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "emptyChild",
+                pbjson::private::base64::encode(&self.empty_child).as_str(),
+            )?;
+        }
+        if self.hash != 0 {
+            let v = HashOp::try_from(self.hash)
+                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.hash)))?;
+            struct_ser.serialize_field("hash", &v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for InnerSpec {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "child_order",
+            "childOrder",
+            "child_size",
+            "childSize",
+            "min_prefix_length",
+            "minPrefixLength",
+            "max_prefix_length",
+            "maxPrefixLength",
+            "empty_child",
+            "emptyChild",
+            "hash",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ChildOrder,
+            ChildSize,
+            MinPrefixLength,
+            MaxPrefixLength,
+            EmptyChild,
+            Hash,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "childOrder" | "child_order" => Ok(GeneratedField::ChildOrder),
+                            "childSize" | "child_size" => Ok(GeneratedField::ChildSize),
+                            "minPrefixLength" | "min_prefix_length" => {
+                                Ok(GeneratedField::MinPrefixLength)
+                            }
+                            "maxPrefixLength" | "max_prefix_length" => {
+                                Ok(GeneratedField::MaxPrefixLength)
+                            }
+                            "emptyChild" | "empty_child" => Ok(GeneratedField::EmptyChild),
+                            "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 = InnerSpec;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ics23.InnerSpec")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<InnerSpec, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut child_order__ = None;
+                let mut child_size__ = None;
+                let mut min_prefix_length__ = None;
+                let mut max_prefix_length__ = None;
+                let mut empty_child__ = None;
+                let mut hash__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::ChildOrder => {
+                            if child_order__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("childOrder"));
+                            }
+                            child_order__ = Some(
+                                map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
+                                    .into_iter()
+                                    .map(|x| x.0)
+                                    .collect(),
+                            );
+                        }
+                        GeneratedField::ChildSize => {
+                            if child_size__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("childSize"));
+                            }
+                            child_size__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::MinPrefixLength => {
+                            if min_prefix_length__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("minPrefixLength"));
+                            }
+                            min_prefix_length__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::MaxPrefixLength => {
+                            if max_prefix_length__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("maxPrefixLength"));
+                            }
+                            max_prefix_length__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::EmptyChild => {
+                            if empty_child__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("emptyChild"));
+                            }
+                            empty_child__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Hash => {
+                            if hash__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("hash"));
+                            }
+                            hash__ = Some(map_.next_value::<HashOp>()? as i32);
+                        }
+                    }
+                }
+                Ok(InnerSpec {
+                    child_order: child_order__.unwrap_or_default(),
+                    child_size: child_size__.unwrap_or_default(),
+                    min_prefix_length: min_prefix_length__.unwrap_or_default(),
+                    max_prefix_length: max_prefix_length__.unwrap_or_default(),
+                    empty_child: empty_child__.unwrap_or_default(),
+                    hash: hash__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("ics23.InnerSpec", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for LeafOp {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.hash != 0 {
+            len += 1;
+        }
+        if self.prehash_key != 0 {
+            len += 1;
+        }
+        if self.prehash_value != 0 {
+            len += 1;
+        }
+        if self.length != 0 {
+            len += 1;
+        }
+        if !self.prefix.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ics23.LeafOp", len)?;
+        if self.hash != 0 {
+            let v = HashOp::try_from(self.hash)
+                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.hash)))?;
+            struct_ser.serialize_field("hash", &v)?;
+        }
+        if self.prehash_key != 0 {
+            let v = HashOp::try_from(self.prehash_key).map_err(|_| {
+                serde::ser::Error::custom(format!("Invalid variant {}", self.prehash_key))
+            })?;
+            struct_ser.serialize_field("prehashKey", &v)?;
+        }
+        if self.prehash_value != 0 {
+            let v = HashOp::try_from(self.prehash_value).map_err(|_| {
+                serde::ser::Error::custom(format!("Invalid variant {}", self.prehash_value))
+            })?;
+            struct_ser.serialize_field("prehashValue", &v)?;
+        }
+        if self.length != 0 {
+            let v = LengthOp::try_from(self.length).map_err(|_| {
+                serde::ser::Error::custom(format!("Invalid variant {}", self.length))
+            })?;
+            struct_ser.serialize_field("length", &v)?;
+        }
+        if !self.prefix.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field(
+                "prefix",
+                pbjson::private::base64::encode(&self.prefix).as_str(),
+            )?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for LeafOp {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "hash",
+            "prehash_key",
+            "prehashKey",
+            "prehash_value",
+            "prehashValue",
+            "length",
+            "prefix",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Hash,
+            PrehashKey,
+            PrehashValue,
+            Length,
+            Prefix,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "hash" => Ok(GeneratedField::Hash),
+                            "prehashKey" | "prehash_key" => Ok(GeneratedField::PrehashKey),
+                            "prehashValue" | "prehash_value" => Ok(GeneratedField::PrehashValue),
+                            "length" => Ok(GeneratedField::Length),
+                            "prefix" => Ok(GeneratedField::Prefix),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = LeafOp;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ics23.LeafOp")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LeafOp, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut hash__ = None;
+                let mut prehash_key__ = None;
+                let mut prehash_value__ = None;
+                let mut length__ = None;
+                let mut prefix__ = 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::<HashOp>()? as i32);
+                        }
+                        GeneratedField::PrehashKey => {
+                            if prehash_key__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("prehashKey"));
+                            }
+                            prehash_key__ = Some(map_.next_value::<HashOp>()? as i32);
+                        }
+                        GeneratedField::PrehashValue => {
+                            if prehash_value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("prehashValue"));
+                            }
+                            prehash_value__ = Some(map_.next_value::<HashOp>()? as i32);
+                        }
+                        GeneratedField::Length => {
+                            if length__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("length"));
+                            }
+                            length__ = Some(map_.next_value::<LengthOp>()? as i32);
+                        }
+                        GeneratedField::Prefix => {
+                            if prefix__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("prefix"));
+                            }
+                            prefix__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(LeafOp {
+                    hash: hash__.unwrap_or_default(),
+                    prehash_key: prehash_key__.unwrap_or_default(),
+                    prehash_value: prehash_value__.unwrap_or_default(),
+                    length: length__.unwrap_or_default(),
+                    prefix: prefix__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("ics23.LeafOp", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for LengthOp {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::NoPrefix => "NO_PREFIX",
+            Self::VarProto => "VAR_PROTO",
+            Self::VarRlp => "VAR_RLP",
+            Self::Fixed32Big => "FIXED32_BIG",
+            Self::Fixed32Little => "FIXED32_LITTLE",
+            Self::Fixed64Big => "FIXED64_BIG",
+            Self::Fixed64Little => "FIXED64_LITTLE",
+            Self::Require32Bytes => "REQUIRE_32_BYTES",
+            Self::Require64Bytes => "REQUIRE_64_BYTES",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for LengthOp {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "NO_PREFIX",
+            "VAR_PROTO",
+            "VAR_RLP",
+            "FIXED32_BIG",
+            "FIXED32_LITTLE",
+            "FIXED64_BIG",
+            "FIXED64_LITTLE",
+            "REQUIRE_32_BYTES",
+            "REQUIRE_64_BYTES",
+        ];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = LengthOp;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                i32::try_from(v)
+                    .ok()
+                    .and_then(|x| x.try_into().ok())
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                i32::try_from(v)
+                    .ok()
+                    .and_then(|x| x.try_into().ok())
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "NO_PREFIX" => Ok(LengthOp::NoPrefix),
+                    "VAR_PROTO" => Ok(LengthOp::VarProto),
+                    "VAR_RLP" => Ok(LengthOp::VarRlp),
+                    "FIXED32_BIG" => Ok(LengthOp::Fixed32Big),
+                    "FIXED32_LITTLE" => Ok(LengthOp::Fixed32Little),
+                    "FIXED64_BIG" => Ok(LengthOp::Fixed64Big),
+                    "FIXED64_LITTLE" => Ok(LengthOp::Fixed64Little),
+                    "REQUIRE_32_BYTES" => Ok(LengthOp::Require32Bytes),
+                    "REQUIRE_64_BYTES" => Ok(LengthOp::Require64Bytes),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for NonExistenceProof {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.key.is_empty() {
+            len += 1;
+        }
+        if self.left.is_some() {
+            len += 1;
+        }
+        if self.right.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ics23.NonExistenceProof", len)?;
+        if !self.key.is_empty() {
+            #[allow(clippy::needless_borrow)]
+            struct_ser
+                .serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?;
+        }
+        if let Some(v) = self.left.as_ref() {
+            struct_ser.serialize_field("left", v)?;
+        }
+        if let Some(v) = self.right.as_ref() {
+            struct_ser.serialize_field("right", v)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for NonExistenceProof {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &["key", "left", "right"];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Key,
+            Left,
+            Right,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "key" => Ok(GeneratedField::Key),
+                            "left" => Ok(GeneratedField::Left),
+                            "right" => Ok(GeneratedField::Right),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = NonExistenceProof;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ics23.NonExistenceProof")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NonExistenceProof, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut key__ = None;
+                let mut left__ = None;
+                let mut right__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Key => {
+                            if key__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("key"));
+                            }
+                            key__ = Some(
+                                map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::Left => {
+                            if left__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("left"));
+                            }
+                            left__ = map_.next_value()?;
+                        }
+                        GeneratedField::Right => {
+                            if right__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("right"));
+                            }
+                            right__ = map_.next_value()?;
+                        }
+                    }
+                }
+                Ok(NonExistenceProof {
+                    key: key__.unwrap_or_default(),
+                    left: left__,
+                    right: right__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("ics23.NonExistenceProof", FIELDS, GeneratedVisitor)
+    }
+}
+#[cfg(feature = "serde")]
+impl serde::Serialize for ProofSpec {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.leaf_spec.is_some() {
+            len += 1;
+        }
+        if self.inner_spec.is_some() {
+            len += 1;
+        }
+        if self.max_depth != 0 {
+            len += 1;
+        }
+        if self.min_depth != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("ics23.ProofSpec", len)?;
+        if let Some(v) = self.leaf_spec.as_ref() {
+            struct_ser.serialize_field("leafSpec", v)?;
+        }
+        if let Some(v) = self.inner_spec.as_ref() {
+            struct_ser.serialize_field("innerSpec", v)?;
+        }
+        if self.max_depth != 0 {
+            struct_ser.serialize_field("maxDepth", &self.max_depth)?;
+        }
+        if self.min_depth != 0 {
+            struct_ser.serialize_field("minDepth", &self.min_depth)?;
+        }
+        struct_ser.end()
+    }
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ProofSpec {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "leaf_spec",
+            "leafSpec",
+            "inner_spec",
+            "innerSpec",
+            "max_depth",
+            "maxDepth",
+            "min_depth",
+            "minDepth",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            LeafSpec,
+            InnerSpec,
+            MaxDepth,
+            MinDepth,
+        }
+        #[cfg(feature = "serde")]
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(
+                        &self,
+                        formatter: &mut std::fmt::Formatter<'_>,
+                    ) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "leafSpec" | "leaf_spec" => Ok(GeneratedField::LeafSpec),
+                            "innerSpec" | "inner_spec" => Ok(GeneratedField::InnerSpec),
+                            "maxDepth" | "max_depth" => Ok(GeneratedField::MaxDepth),
+                            "minDepth" | "min_depth" => Ok(GeneratedField::MinDepth),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ProofSpec;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct ics23.ProofSpec")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProofSpec, V::Error>
+            where
+                V: serde::de::MapAccess<'de>,
+            {
+                let mut leaf_spec__ = None;
+                let mut inner_spec__ = None;
+                let mut max_depth__ = None;
+                let mut min_depth__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::LeafSpec => {
+                            if leaf_spec__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("leafSpec"));
+                            }
+                            leaf_spec__ = map_.next_value()?;
+                        }
+                        GeneratedField::InnerSpec => {
+                            if inner_spec__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("innerSpec"));
+                            }
+                            inner_spec__ = map_.next_value()?;
+                        }
+                        GeneratedField::MaxDepth => {
+                            if max_depth__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("maxDepth"));
+                            }
+                            max_depth__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                        GeneratedField::MinDepth => {
+                            if min_depth__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("minDepth"));
+                            }
+                            min_depth__ = Some(
+                                map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
+                                    .0,
+                            );
+                        }
+                    }
+                }
+                Ok(ProofSpec {
+                    leaf_spec: leaf_spec__,
+                    inner_spec: inner_spec__,
+                    max_depth: max_depth__.unwrap_or_default(),
+                    min_depth: min_depth__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("ics23.ProofSpec", FIELDS, GeneratedVisitor)
+    }
+}
diff --git a/proto-build/buf.ibc.gen.yaml b/proto-build/buf.ibc.gen.yaml
new file mode 100644
index 00000000..8126d36e
--- /dev/null
+++ b/proto-build/buf.ibc.gen.yaml
@@ -0,0 +1,8 @@
+version: v1
+plugins:
+  - plugin: buf.build/community/neoeinstein-prost:v0.3.1
+    out: .
+  - plugin: buf.build/community/neoeinstein-prost-serde:v0.3.0
+    out: .
+  - plugin: buf.build/community/neoeinstein-tonic:v0.3.0
+    out: .
diff --git a/proto-build/src/main.rs b/proto-build/src/main.rs
index c3816aa3..90dbc4ab 100644
--- a/proto-build/src/main.rs
+++ b/proto-build/src/main.rs
@@ -230,9 +230,9 @@ fn compile_sdk_protos_and_services(out_dir: &Path) {
 }
 
 fn compile_wasmd_proto_and_services(out_dir: &Path) {
-    let sdk_dir = Path::new(WASMD_DIR);
-    let proto_path = sdk_dir.join("proto");
-    let proto_paths = [format!("{}/proto/cosmwasm/wasm", sdk_dir.display())];
+    let wasmd_dir = Path::new(WASMD_DIR);
+    let proto_path = wasmd_dir.join("proto");
+    let proto_paths = [format!("{}/proto/cosmwasm/wasm", wasmd_dir.display())];
 
     // List available proto files
     let mut protos: Vec<PathBuf> = vec![];
@@ -252,13 +252,7 @@ fn compile_ibc_protos_and_services(out_dir: &Path) {
 
     let root = env!("CARGO_MANIFEST_DIR");
     let ibc_dir = Path::new(IBC_DIR);
-
-    let proto_includes_paths = [
-        format!("{}/../proto", root),
-        format!("{}/proto", ibc_dir.display()),
-        format!("{}/third_party/proto", ibc_dir.display()),
-    ];
-
+    let proto_path = ibc_dir.join("proto");
     let proto_paths = [
         format!("{}/../proto/definitions/mock", root),
         format!(
@@ -281,22 +275,13 @@ fn compile_ibc_protos_and_services(out_dir: &Path) {
     let mut protos: Vec<PathBuf> = vec![];
     collect_protos(&proto_paths, &mut protos);
 
-    let includes: Vec<PathBuf> = proto_includes_paths.iter().map(PathBuf::from).collect();
-
     // Enable generation of `prost::Name` annotations for all types
     let mut config = prost_build::Config::new();
     config.enable_type_names();
 
     // Compile all of the proto files, along with the grpc service clients
     info!("Compiling proto definitions and clients for GRPC services!");
-    tonic_build::configure()
-        .build_client(true)
-        .build_server(false)
-        .out_dir(out_dir)
-        .extern_path(".tendermint", "::tendermint_proto")
-        .compile_with_config(config, &protos, &includes)
-        .unwrap();
-
+    run_buf("buf.ibc.gen.yaml", proto_path, out_dir);
     info!("=> Done!");
 }