From f24b8276dab306b6da90d3e136804ebb00fc9c39 Mon Sep 17 00:00:00 2001 From: Luca Joss Date: Wed, 7 Feb 2024 15:08:51 +0100 Subject: [PATCH 1/3] Update ibc-go protos to v8.1.0 --- src/IBC_GO_COMMIT | 2 +- ...tions.interchain_accounts.controller.v1.rs | 5 + ...interchain_accounts.controller.v1.serde.rs | 19 + src/prost/ibc.applications.transfer.v1.rs | 4 + .../ibc.applications.transfer.v1.serde.rs | 18 + src/prost/ibc.core.channel.v1.rs | 2043 +++++- src/prost/ibc.core.channel.v1.serde.rs | 6238 +++++++++++++---- src/prost/ibc.lightclients.wasm.v1.rs | 1100 --- src/prost/ibc.lightclients.wasm.v1.serde.rs | 1592 ----- src/prost/proto_descriptor.bin | Bin 740422 -> 754051 bytes 10 files changed, 6790 insertions(+), 4231 deletions(-) delete mode 100644 src/prost/ibc.lightclients.wasm.v1.rs delete mode 100644 src/prost/ibc.lightclients.wasm.v1.serde.rs diff --git a/src/IBC_GO_COMMIT b/src/IBC_GO_COMMIT index 5a5a9e9..19b35bf 100644 --- a/src/IBC_GO_COMMIT +++ b/src/IBC_GO_COMMIT @@ -1 +1 @@ -57fcdb9a9a9db9b206f7df2f955866dc4e10fef4 \ No newline at end of file +7e01c9149149b9d4b1d871e58eb88a22f15bdb3c \ No newline at end of file diff --git a/src/prost/ibc.applications.interchain_accounts.controller.v1.rs b/src/prost/ibc.applications.interchain_accounts.controller.v1.rs index 00e306a..81fe983 100644 --- a/src/prost/ibc.applications.interchain_accounts.controller.v1.rs +++ b/src/prost/ibc.applications.interchain_accounts.controller.v1.rs @@ -26,6 +26,11 @@ pub struct MsgRegisterInterchainAccount { pub connection_id: ::prost::alloc::string::String, #[prost(string, tag = "3")] pub version: ::prost::alloc::string::String, + #[prost( + enumeration = "super::super::super::super::core::channel::v1::Order", + tag = "4" + )] + pub ordering: i32, } impl ::prost::Name for MsgRegisterInterchainAccount { const NAME: &'static str = "MsgRegisterInterchainAccount"; diff --git a/src/prost/ibc.applications.interchain_accounts.controller.v1.serde.rs b/src/prost/ibc.applications.interchain_accounts.controller.v1.serde.rs index b438d22..75bea08 100644 --- a/src/prost/ibc.applications.interchain_accounts.controller.v1.serde.rs +++ b/src/prost/ibc.applications.interchain_accounts.controller.v1.serde.rs @@ -15,6 +15,9 @@ impl serde::Serialize for MsgRegisterInterchainAccount { if true { len += 1; } + if true { + len += 1; + } let mut struct_ser = serializer.serialize_struct("ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccount", len)?; if true { struct_ser.serialize_field("owner", &self.owner)?; @@ -25,6 +28,11 @@ impl serde::Serialize for MsgRegisterInterchainAccount { if true { struct_ser.serialize_field("version", &self.version)?; } + if true { + let v = super::super::super::super::core::channel::v1::Order::try_from(self.ordering) + .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.ordering)))?; + struct_ser.serialize_field("ordering", &v)?; + } struct_ser.end() } } @@ -39,6 +47,7 @@ impl<'de> serde::Deserialize<'de> for MsgRegisterInterchainAccount { "connection_id", "connectionId", "version", + "ordering", ]; #[allow(clippy::enum_variant_names)] @@ -46,6 +55,7 @@ impl<'de> serde::Deserialize<'de> for MsgRegisterInterchainAccount { Owner, ConnectionId, Version, + Ordering, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -70,6 +80,7 @@ impl<'de> serde::Deserialize<'de> for MsgRegisterInterchainAccount { "owner" => Ok(GeneratedField::Owner), "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId), "version" => Ok(GeneratedField::Version), + "ordering" => Ok(GeneratedField::Ordering), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -92,6 +103,7 @@ impl<'de> serde::Deserialize<'de> for MsgRegisterInterchainAccount { let mut owner__ = None; let mut connection_id__ = None; let mut version__ = None; + let mut ordering__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::Owner => { @@ -112,12 +124,19 @@ impl<'de> serde::Deserialize<'de> for MsgRegisterInterchainAccount { } version__ = Some(map_.next_value()?); } + GeneratedField::Ordering => { + if ordering__.is_some() { + return Err(serde::de::Error::duplicate_field("ordering")); + } + ordering__ = Some(map_.next_value::()? as i32); + } } } Ok(MsgRegisterInterchainAccount { owner: owner__.unwrap_or_default(), connection_id: connection_id__.unwrap_or_default(), version: version__.unwrap_or_default(), + ordering: ordering__.unwrap_or_default(), }) } } diff --git a/src/prost/ibc.applications.transfer.v1.rs b/src/prost/ibc.applications.transfer.v1.rs index 0c84ba3..70c3a6c 100644 --- a/src/prost/ibc.applications.transfer.v1.rs +++ b/src/prost/ibc.applications.transfer.v1.rs @@ -1434,6 +1434,10 @@ pub struct Allocation { /// allow list of receivers, an empty allow list permits any receiver address #[prost(string, repeated, tag = "4")] pub allow_list: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// allow list of packet data keys, an empty list prohibits all packet data keys; + /// a list only with "*" permits any packet data key + #[prost(string, repeated, tag = "5")] + pub allowed_packet_data: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } impl ::prost::Name for Allocation { const NAME: &'static str = "Allocation"; diff --git a/src/prost/ibc.applications.transfer.v1.serde.rs b/src/prost/ibc.applications.transfer.v1.serde.rs index 23d490a..2daf7aa 100644 --- a/src/prost/ibc.applications.transfer.v1.serde.rs +++ b/src/prost/ibc.applications.transfer.v1.serde.rs @@ -18,6 +18,9 @@ impl serde::Serialize for Allocation { if true { len += 1; } + if true { + len += 1; + } let mut struct_ser = serializer.serialize_struct("ibc.applications.transfer.v1.Allocation", len)?; if true { struct_ser.serialize_field("sourcePort", &self.source_port)?; @@ -31,6 +34,9 @@ impl serde::Serialize for Allocation { if true { struct_ser.serialize_field("allowList", &self.allow_list)?; } + if true { + struct_ser.serialize_field("allowedPacketData", &self.allowed_packet_data)?; + } struct_ser.end() } } @@ -49,6 +55,8 @@ impl<'de> serde::Deserialize<'de> for Allocation { "spendLimit", "allow_list", "allowList", + "allowed_packet_data", + "allowedPacketData", ]; #[allow(clippy::enum_variant_names)] @@ -57,6 +65,7 @@ impl<'de> serde::Deserialize<'de> for Allocation { SourceChannel, SpendLimit, AllowList, + AllowedPacketData, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -82,6 +91,7 @@ impl<'de> serde::Deserialize<'de> for Allocation { "sourceChannel" | "source_channel" => Ok(GeneratedField::SourceChannel), "spendLimit" | "spend_limit" => Ok(GeneratedField::SpendLimit), "allowList" | "allow_list" => Ok(GeneratedField::AllowList), + "allowedPacketData" | "allowed_packet_data" => Ok(GeneratedField::AllowedPacketData), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -105,6 +115,7 @@ impl<'de> serde::Deserialize<'de> for Allocation { let mut source_channel__ = None; let mut spend_limit__ = None; let mut allow_list__ = None; + let mut allowed_packet_data__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::SourcePort => { @@ -131,6 +142,12 @@ impl<'de> serde::Deserialize<'de> for Allocation { } allow_list__ = Some(map_.next_value()?); } + GeneratedField::AllowedPacketData => { + if allowed_packet_data__.is_some() { + return Err(serde::de::Error::duplicate_field("allowedPacketData")); + } + allowed_packet_data__ = Some(map_.next_value()?); + } } } Ok(Allocation { @@ -138,6 +155,7 @@ impl<'de> serde::Deserialize<'de> for Allocation { source_channel: source_channel__.unwrap_or_default(), spend_limit: spend_limit__.unwrap_or_default(), allow_list: allow_list__.unwrap_or_default(), + allowed_packet_data: allowed_packet_data__.unwrap_or_default(), }) } } diff --git a/src/prost/ibc.core.channel.v1.rs b/src/prost/ibc.core.channel.v1.rs index b354e65..53c79e7 100644 --- a/src/prost/ibc.core.channel.v1.rs +++ b/src/prost/ibc.core.channel.v1.rs @@ -24,6 +24,10 @@ pub struct Channel { /// opaque channel version, which is agreed upon during the handshake #[prost(string, tag = "5")] pub version: ::prost::alloc::string::String, + /// upgrade sequence indicates the latest upgrade attempt performed by this channel + /// the value of 0 indicates the channel has never been upgraded + #[prost(uint64, tag = "6")] + pub upgrade_sequence: u64, } impl ::prost::Name for Channel { const NAME: &'static str = "Channel"; @@ -59,6 +63,10 @@ pub struct IdentifiedChannel { /// channel identifier #[prost(string, tag = "7")] pub channel_id: ::prost::alloc::string::String, + /// upgrade sequence indicates the latest upgrade attempt performed by this channel + /// the value of 0 indicates the channel has never been upgraded + #[prost(uint64, tag = "8")] + pub upgrade_sequence: u64, } impl ::prost::Name for IdentifiedChannel { const NAME: &'static str = "IdentifiedChannel"; @@ -230,8 +238,23 @@ impl ::prost::Name for Timeout { ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) } } +/// Params defines the set of IBC channel parameters. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Params { + /// the relative timeout after which channel upgrades will time out. + #[prost(message, optional, tag = "1")] + pub upgrade_timeout: ::core::option::Option, +} +impl ::prost::Name for Params { + const NAME: &'static str = "Params"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// State defines if a channel is in one of the following states: -/// CLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED. +/// CLOSED, INIT, TRYOPEN, OPEN, FLUSHING, FLUSHCOMPLETE or UNINITIALIZED. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum State { @@ -247,6 +270,10 @@ pub enum State { /// A channel has been closed and can no longer be used to send or receive /// packets. Closed = 4, + /// A channel has just accepted the upgrade handshake attempt and is flushing in-flight packets. + Flushing = 5, + /// A channel has just completed flushing any in-flight packets. + Flushcomplete = 6, } impl State { /// String value of the enum field names used in the ProtoBuf definition. @@ -260,6 +287,8 @@ impl State { State::Tryopen => "STATE_TRYOPEN", State::Open => "STATE_OPEN", State::Closed => "STATE_CLOSED", + State::Flushing => "STATE_FLUSHING", + State::Flushcomplete => "STATE_FLUSHCOMPLETE", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -270,6 +299,8 @@ impl State { "STATE_TRYOPEN" => Some(Self::Tryopen), "STATE_OPEN" => Some(Self::Open), "STATE_CLOSED" => Some(Self::Closed), + "STATE_FLUSHING" => Some(Self::Flushing), + "STATE_FLUSHCOMPLETE" => Some(Self::Flushcomplete), _ => None, } } @@ -329,6 +360,8 @@ pub struct GenesisState { /// the sequence for the next generated channel identifier #[prost(uint64, tag = "8")] pub next_channel_sequence: u64, + #[prost(message, optional, tag = "9")] + pub params: ::core::option::Option, } impl ::prost::Name for GenesisState { const NAME: &'static str = "GenesisState"; @@ -356,6 +389,67 @@ impl ::prost::Name for PacketSequence { ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) } } +/// Upgrade is a verifiable type which contains the relevant information +/// for an attempted upgrade. It provides the proposed changes to the channel +/// end, the timeout for this upgrade attempt and the next packet sequence +/// which allows the counterparty to efficiently know the highest sequence it has received. +/// The next sequence send is used for pruning and upgrading from unordered to ordered channels. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Upgrade { + #[prost(message, optional, tag = "1")] + pub fields: ::core::option::Option, + #[prost(message, optional, tag = "2")] + pub timeout: ::core::option::Option, + #[prost(uint64, tag = "3")] + pub next_sequence_send: u64, +} +impl ::prost::Name for Upgrade { + const NAME: &'static str = "Upgrade"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// UpgradeFields are the fields in a channel end which may be changed +/// during a channel upgrade. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UpgradeFields { + #[prost(enumeration = "Order", tag = "1")] + pub ordering: i32, + #[prost(string, repeated, tag = "2")] + pub connection_hops: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(string, tag = "3")] + pub version: ::prost::alloc::string::String, +} +impl ::prost::Name for UpgradeFields { + const NAME: &'static str = "UpgradeFields"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// ErrorReceipt defines a type which encapsulates the upgrade sequence and error associated with the +/// upgrade handshake failure. When a channel upgrade handshake is aborted both chains are expected to increment to the +/// next sequence. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ErrorReceipt { + /// the channel upgrade sequence + #[prost(uint64, tag = "1")] + pub sequence: u64, + /// the error message detailing the cause of failure + #[prost(string, tag = "2")] + pub message: ::prost::alloc::string::String, +} +impl ::prost::Name for ErrorReceipt { + const NAME: &'static str = "ErrorReceipt"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// 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)] @@ -440,6 +534,9 @@ impl ::prost::Name for MsgChannelOpenTryResponse { } /// MsgChannelOpenAck defines a msg sent by a Relayer to Chain A to acknowledge /// the change of channel state to TRYOPEN on Chain B. +/// WARNING: a channel upgrade MUST NOT initialize an upgrade for this channel +/// in the same block as executing this message otherwise the counterparty will +/// be incapable of opening. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelOpenAck { @@ -556,6 +653,8 @@ pub struct MsgChannelCloseConfirm { pub proof_height: ::core::option::Option, #[prost(string, tag = "5")] pub signer: ::prost::alloc::string::String, + #[prost(uint64, tag = "6")] + pub counterparty_upgrade_sequence: u64, } impl ::prost::Name for MsgChannelCloseConfirm { const NAME: &'static str = "MsgChannelCloseConfirm"; @@ -662,6 +761,8 @@ pub struct MsgTimeoutOnClose { pub next_sequence_recv: u64, #[prost(string, tag = "6")] pub signer: ::prost::alloc::string::String, + #[prost(uint64, tag = "7")] + pub counterparty_upgrade_sequence: u64, } impl ::prost::Name for MsgTimeoutOnClose { const NAME: &'static str = "MsgTimeoutOnClose"; @@ -720,176 +821,526 @@ impl ::prost::Name for MsgAcknowledgementResponse { ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) } } -/// ResponseResultType defines the possible outcomes of the execution of a message -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] -#[repr(i32)] -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, +/// MsgChannelUpgradeInit defines the request type for the ChannelUpgradeInit rpc +/// WARNING: Initializing a channel upgrade in the same block as opening the channel +/// may result in the counterparty being incapable of opening. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeInit { + #[prost(string, tag = "1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(message, optional, tag = "3")] + pub fields: ::core::option::Option, + #[prost(string, tag = "4")] + pub signer: ::prost::alloc::string::String, } -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", - } +impl ::prost::Name for MsgChannelUpgradeInit { + const NAME: &'static str = "MsgChannelUpgradeInit"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "RESPONSE_RESULT_TYPE_UNSPECIFIED" => Some(Self::Unspecified), - "RESPONSE_RESULT_TYPE_NOOP" => Some(Self::Noop), - "RESPONSE_RESULT_TYPE_SUCCESS" => Some(Self::Success), - _ => None, - } +} +/// MsgChannelUpgradeInitResponse defines the MsgChannelUpgradeInit response type +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeInitResponse { + #[prost(message, optional, tag = "1")] + pub upgrade: ::core::option::Option, + #[prost(uint64, tag = "2")] + pub upgrade_sequence: u64, +} +impl ::prost::Name for MsgChannelUpgradeInitResponse { + const NAME: &'static str = "MsgChannelUpgradeInitResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) } } -/// Generated client implementations. -#[cfg(feature = "client")] -pub mod msg_client { - #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] - use tonic::codegen::*; - use tonic::codegen::http::Uri; - /// Msg defines the ibc/channel Msg service. - #[derive(Debug, Clone)] - pub struct MsgClient { - inner: tonic::client::Grpc, +/// MsgChannelUpgradeTry defines the request type for the ChannelUpgradeTry rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeTry { + #[prost(string, tag = "1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(string, repeated, tag = "3")] + pub proposed_upgrade_connection_hops: ::prost::alloc::vec::Vec< + ::prost::alloc::string::String, + >, + #[prost(message, optional, tag = "4")] + pub counterparty_upgrade_fields: ::core::option::Option, + #[prost(uint64, tag = "5")] + pub counterparty_upgrade_sequence: u64, + #[prost(bytes = "vec", tag = "6")] + pub proof_channel: ::prost::alloc::vec::Vec, + #[prost(bytes = "vec", tag = "7")] + pub proof_upgrade: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "8")] + pub proof_height: ::core::option::Option, + #[prost(string, tag = "9")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgChannelUpgradeTry { + const NAME: &'static str = "MsgChannelUpgradeTry"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) } - impl MsgClient { - /// Attempt to create a new client by connecting to a given endpoint. - pub async fn connect(dst: D) -> Result - where - D: TryInto, - D::Error: Into, - { - let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; - Ok(Self::new(conn)) - } +} +/// MsgChannelUpgradeTryResponse defines the MsgChannelUpgradeTry response type +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeTryResponse { + #[prost(message, optional, tag = "1")] + pub upgrade: ::core::option::Option, + #[prost(uint64, tag = "2")] + pub upgrade_sequence: u64, + #[prost(enumeration = "ResponseResultType", tag = "3")] + pub result: i32, +} +impl ::prost::Name for MsgChannelUpgradeTryResponse { + const NAME: &'static str = "MsgChannelUpgradeTryResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) } - impl MsgClient - where - T: tonic::client::GrpcService, - T::Error: Into, - T::ResponseBody: Body + Send + 'static, - ::Error: Into + Send, - { - pub fn new(inner: T) -> Self { - let inner = tonic::client::Grpc::new(inner); - Self { inner } - } - pub fn with_origin(inner: T, origin: Uri) -> Self { - let inner = tonic::client::Grpc::with_origin(inner, origin); - Self { inner } - } - pub fn with_interceptor( - inner: T, - interceptor: F, - ) -> MsgClient> - where - F: tonic::service::Interceptor, - T::ResponseBody: Default, - T: tonic::codegen::Service< - http::Request, - Response = http::Response< - >::ResponseBody, - >, - >, - , - >>::Error: Into + 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, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - > { - self.inner - .ready() - .await - .map_err(|e| { - tonic::Status::new( - tonic::Code::Unknown, - format!("Service was not ready: {}", e.into()), - ) - })?; - let codec = tonic::codec::ProstCodec::default(); - let path = http::uri::PathAndQuery::from_static( - "/ibc.core.channel.v1.Msg/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, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - > { - self.inner - .ready() - .await - .map_err(|e| { - tonic::Status::new( - tonic::Code::Unknown, - format!("Service was not ready: {}", e.into()), - ) - })?; - let codec = tonic::codec::ProstCodec::default(); - let path = http::uri::PathAndQuery::from_static( - "/ibc.core.channel.v1.Msg/ChannelOpenTry", - ); - let mut req = request.into_request(); - req.extensions_mut() - .insert(GrpcMethod::new("ibc.core.channel.v1.Msg", "ChannelOpenTry")); +} +/// MsgChannelUpgradeAck defines the request type for the ChannelUpgradeAck rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeAck { + #[prost(string, tag = "1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(message, optional, tag = "3")] + pub counterparty_upgrade: ::core::option::Option, + #[prost(bytes = "vec", tag = "4")] + pub proof_channel: ::prost::alloc::vec::Vec, + #[prost(bytes = "vec", tag = "5")] + pub proof_upgrade: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "6")] + pub proof_height: ::core::option::Option, + #[prost(string, tag = "7")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgChannelUpgradeAck { + const NAME: &'static str = "MsgChannelUpgradeAck"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// MsgChannelUpgradeAckResponse defines MsgChannelUpgradeAck response type +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeAckResponse { + #[prost(enumeration = "ResponseResultType", tag = "1")] + pub result: i32, +} +impl ::prost::Name for MsgChannelUpgradeAckResponse { + const NAME: &'static str = "MsgChannelUpgradeAckResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// MsgChannelUpgradeConfirm defines the request type for the ChannelUpgradeConfirm rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeConfirm { + #[prost(string, tag = "1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(enumeration = "State", tag = "3")] + pub counterparty_channel_state: i32, + #[prost(message, optional, tag = "4")] + pub counterparty_upgrade: ::core::option::Option, + #[prost(bytes = "vec", tag = "5")] + pub proof_channel: ::prost::alloc::vec::Vec, + #[prost(bytes = "vec", tag = "6")] + pub proof_upgrade: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "7")] + pub proof_height: ::core::option::Option, + #[prost(string, tag = "8")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgChannelUpgradeConfirm { + const NAME: &'static str = "MsgChannelUpgradeConfirm"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// MsgChannelUpgradeConfirmResponse defines MsgChannelUpgradeConfirm response type +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeConfirmResponse { + #[prost(enumeration = "ResponseResultType", tag = "1")] + pub result: i32, +} +impl ::prost::Name for MsgChannelUpgradeConfirmResponse { + const NAME: &'static str = "MsgChannelUpgradeConfirmResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// MsgChannelUpgradeOpen defines the request type for the ChannelUpgradeOpen rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeOpen { + #[prost(string, tag = "1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(enumeration = "State", tag = "3")] + pub counterparty_channel_state: i32, + #[prost(uint64, tag = "4")] + pub counterparty_upgrade_sequence: u64, + #[prost(bytes = "vec", tag = "5")] + pub proof_channel: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "6")] + pub proof_height: ::core::option::Option, + #[prost(string, tag = "7")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgChannelUpgradeOpen { + const NAME: &'static str = "MsgChannelUpgradeOpen"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// MsgChannelUpgradeOpenResponse defines the MsgChannelUpgradeOpen response type +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeOpenResponse {} +impl ::prost::Name for MsgChannelUpgradeOpenResponse { + const NAME: &'static str = "MsgChannelUpgradeOpenResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// MsgChannelUpgradeTimeout defines the request type for the ChannelUpgradeTimeout rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeTimeout { + #[prost(string, tag = "1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(message, optional, tag = "3")] + pub counterparty_channel: ::core::option::Option, + #[prost(bytes = "vec", tag = "4")] + pub proof_channel: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "5")] + pub proof_height: ::core::option::Option, + #[prost(string, tag = "6")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgChannelUpgradeTimeout { + const NAME: &'static str = "MsgChannelUpgradeTimeout"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// MsgChannelUpgradeTimeoutRepsonse defines the MsgChannelUpgradeTimeout response type +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeTimeoutResponse {} +impl ::prost::Name for MsgChannelUpgradeTimeoutResponse { + const NAME: &'static str = "MsgChannelUpgradeTimeoutResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// MsgChannelUpgradeCancel defines the request type for the ChannelUpgradeCancel rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeCancel { + #[prost(string, tag = "1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(message, optional, tag = "3")] + pub error_receipt: ::core::option::Option, + #[prost(bytes = "vec", tag = "4")] + pub proof_error_receipt: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "5")] + pub proof_height: ::core::option::Option, + #[prost(string, tag = "6")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgChannelUpgradeCancel { + const NAME: &'static str = "MsgChannelUpgradeCancel"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// MsgChannelUpgradeCancelResponse defines the MsgChannelUpgradeCancel response type +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeCancelResponse {} +impl ::prost::Name for MsgChannelUpgradeCancelResponse { + const NAME: &'static str = "MsgChannelUpgradeCancelResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// MsgUpdateParams is the MsgUpdateParams request type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgUpdateParams { + /// authority is the address that controls the module (defaults to x/gov unless overwritten). + #[prost(string, tag = "1")] + pub authority: ::prost::alloc::string::String, + /// params defines the channel parameters to update. + /// + /// NOTE: All parameters must be supplied. + #[prost(message, optional, tag = "2")] + pub params: ::core::option::Option, +} +impl ::prost::Name for MsgUpdateParams { + const NAME: &'static str = "MsgUpdateParams"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// MsgUpdateParamsResponse defines the MsgUpdateParams response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgUpdateParamsResponse {} +impl ::prost::Name for MsgUpdateParamsResponse { + const NAME: &'static str = "MsgUpdateParamsResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// MsgPruneAcknowledgements defines the request type for the PruneAcknowledgements rpc. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgPruneAcknowledgements { + #[prost(string, tag = "1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(uint64, tag = "3")] + pub limit: u64, + #[prost(string, tag = "4")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgPruneAcknowledgements { + const NAME: &'static str = "MsgPruneAcknowledgements"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// MsgPruneAcknowledgementsResponse defines the response type for the PruneAcknowledgements rpc. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgPruneAcknowledgementsResponse { + /// Number of sequences pruned (includes both packet acknowledgements and packet receipts where appropriate). + #[prost(uint64, tag = "1")] + pub total_pruned_sequences: u64, + /// Number of sequences left after pruning. + #[prost(uint64, tag = "2")] + pub total_remaining_sequences: u64, +} +impl ::prost::Name for MsgPruneAcknowledgementsResponse { + const NAME: &'static str = "MsgPruneAcknowledgementsResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// 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, + /// The message was executed unsuccessfully + Failure = 3, +} +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", + ResponseResultType::Failure => "RESPONSE_RESULT_TYPE_FAILURE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "RESPONSE_RESULT_TYPE_UNSPECIFIED" => Some(Self::Unspecified), + "RESPONSE_RESULT_TYPE_NOOP" => Some(Self::Noop), + "RESPONSE_RESULT_TYPE_SUCCESS" => Some(Self::Success), + "RESPONSE_RESULT_TYPE_FAILURE" => Some(Self::Failure), + _ => None, + } + } +} +/// Generated client implementations. +#[cfg(feature = "client")] +pub mod msg_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + /// Msg defines the ibc/channel Msg service. + #[derive(Debug, Clone)] + pub struct MsgClient { + inner: tonic::client::Grpc, + } + impl MsgClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl MsgClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> MsgClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + 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, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.core.channel.v1.Msg/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, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.core.channel.v1.Msg/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. @@ -1105,6 +1556,254 @@ pub mod msg_client { .insert(GrpcMethod::new("ibc.core.channel.v1.Msg", "Acknowledgement")); self.inner.unary(req, path, codec).await } + /// ChannelUpgradeInit defines a rpc handler method for MsgChannelUpgradeInit. + pub async fn channel_upgrade_init( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.core.channel.v1.Msg/ChannelUpgradeInit", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("ibc.core.channel.v1.Msg", "ChannelUpgradeInit"), + ); + self.inner.unary(req, path, codec).await + } + /// ChannelUpgradeTry defines a rpc handler method for MsgChannelUpgradeTry. + pub async fn channel_upgrade_try( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.core.channel.v1.Msg/ChannelUpgradeTry", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("ibc.core.channel.v1.Msg", "ChannelUpgradeTry")); + self.inner.unary(req, path, codec).await + } + /// ChannelUpgradeAck defines a rpc handler method for MsgChannelUpgradeAck. + pub async fn channel_upgrade_ack( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.core.channel.v1.Msg/ChannelUpgradeAck", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("ibc.core.channel.v1.Msg", "ChannelUpgradeAck")); + self.inner.unary(req, path, codec).await + } + /// ChannelUpgradeConfirm defines a rpc handler method for MsgChannelUpgradeConfirm. + pub async fn channel_upgrade_confirm( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.core.channel.v1.Msg/ChannelUpgradeConfirm", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("ibc.core.channel.v1.Msg", "ChannelUpgradeConfirm"), + ); + self.inner.unary(req, path, codec).await + } + /// ChannelUpgradeOpen defines a rpc handler method for MsgChannelUpgradeOpen. + pub async fn channel_upgrade_open( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.core.channel.v1.Msg/ChannelUpgradeOpen", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("ibc.core.channel.v1.Msg", "ChannelUpgradeOpen"), + ); + self.inner.unary(req, path, codec).await + } + /// ChannelUpgradeTimeout defines a rpc handler method for MsgChannelUpgradeTimeout. + pub async fn channel_upgrade_timeout( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.core.channel.v1.Msg/ChannelUpgradeTimeout", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("ibc.core.channel.v1.Msg", "ChannelUpgradeTimeout"), + ); + self.inner.unary(req, path, codec).await + } + /// ChannelUpgradeCancel defines a rpc handler method for MsgChannelUpgradeCancel. + pub async fn channel_upgrade_cancel( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.core.channel.v1.Msg/ChannelUpgradeCancel", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("ibc.core.channel.v1.Msg", "ChannelUpgradeCancel"), + ); + self.inner.unary(req, path, codec).await + } + /// UpdateChannelParams defines a rpc handler method for MsgUpdateParams. + pub async fn update_channel_params( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.core.channel.v1.Msg/UpdateChannelParams", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("ibc.core.channel.v1.Msg", "UpdateChannelParams"), + ); + self.inner.unary(req, path, codec).await + } + /// PruneAcknowledgements defines a rpc handler method for MsgPruneAcknowledgements. + pub async fn prune_acknowledgements( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.core.channel.v1.Msg/PruneAcknowledgements", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("ibc.core.channel.v1.Msg", "PruneAcknowledgements"), + ); + self.inner.unary(req, path, codec).await + } } } /// Generated server implementations. @@ -1159,41 +1858,113 @@ pub mod msg_server { /// MsgChannelCloseConfirm. async fn channel_close_confirm( &self, - request: tonic::Request, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// RecvPacket defines a rpc handler method for MsgRecvPacket. + async fn recv_packet( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Timeout defines a rpc handler method for MsgTimeout. + async fn timeout( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// TimeoutOnClose defines a rpc handler method for MsgTimeoutOnClose. + async fn timeout_on_close( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Acknowledgement defines a rpc handler method for MsgAcknowledgement. + async fn acknowledgement( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// ChannelUpgradeInit defines a rpc handler method for MsgChannelUpgradeInit. + async fn channel_upgrade_init( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// ChannelUpgradeTry defines a rpc handler method for MsgChannelUpgradeTry. + async fn channel_upgrade_try( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// ChannelUpgradeAck defines a rpc handler method for MsgChannelUpgradeAck. + async fn channel_upgrade_ack( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// ChannelUpgradeConfirm defines a rpc handler method for MsgChannelUpgradeConfirm. + async fn channel_upgrade_confirm( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// ChannelUpgradeOpen defines a rpc handler method for MsgChannelUpgradeOpen. + async fn channel_upgrade_open( + &self, + request: tonic::Request, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, >; - /// RecvPacket defines a rpc handler method for MsgRecvPacket. - async fn recv_packet( + /// ChannelUpgradeTimeout defines a rpc handler method for MsgChannelUpgradeTimeout. + async fn channel_upgrade_timeout( &self, - request: tonic::Request, + request: tonic::Request, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, >; - /// Timeout defines a rpc handler method for MsgTimeout. - async fn timeout( + /// ChannelUpgradeCancel defines a rpc handler method for MsgChannelUpgradeCancel. + async fn channel_upgrade_cancel( &self, - request: tonic::Request, + request: tonic::Request, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, >; - /// TimeoutOnClose defines a rpc handler method for MsgTimeoutOnClose. - async fn timeout_on_close( + /// UpdateChannelParams defines a rpc handler method for MsgUpdateParams. + async fn update_channel_params( &self, - request: tonic::Request, + request: tonic::Request, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, >; - /// Acknowledgement defines a rpc handler method for MsgAcknowledgement. - async fn acknowledgement( + /// PruneAcknowledgements defines a rpc handler method for MsgPruneAcknowledgements. + async fn prune_acknowledgements( &self, - request: tonic::Request, + request: tonic::Request, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, >; } @@ -1279,21 +2050,289 @@ pub mod msg_server { match req.uri().path() { "/ibc.core.channel.v1.Msg/ChannelOpenInit" => { #[allow(non_camel_case_types)] - struct ChannelOpenInitSvc(pub Arc); - impl tonic::server::UnaryService - for ChannelOpenInitSvc { - type Response = super::MsgChannelOpenInitResponse; + struct ChannelOpenInitSvc(pub Arc); + impl tonic::server::UnaryService + for ChannelOpenInitSvc { + type Response = super::MsgChannelOpenInitResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::channel_open_init(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = 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(pub Arc); + impl tonic::server::UnaryService + for ChannelOpenTrySvc { + type Response = super::MsgChannelOpenTryResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::channel_open_try(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = 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(pub Arc); + impl tonic::server::UnaryService + for ChannelOpenAckSvc { + type Response = super::MsgChannelOpenAckResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::channel_open_ack(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = 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(pub Arc); + impl< + T: Msg, + > tonic::server::UnaryService + for ChannelOpenConfirmSvc { + type Response = super::MsgChannelOpenConfirmResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::channel_open_confirm(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = 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(pub Arc); + impl tonic::server::UnaryService + for ChannelCloseInitSvc { + type Response = super::MsgChannelCloseInitResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::channel_close_init(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = 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(pub Arc); + impl< + T: Msg, + > tonic::server::UnaryService + for ChannelCloseConfirmSvc { + type Response = super::MsgChannelCloseConfirmResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::channel_close_confirm(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = 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(pub Arc); + impl tonic::server::UnaryService + for RecvPacketSvc { + type Response = super::MsgRecvPacketResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::channel_open_init(&inner, request).await + ::recv_packet(&inner, request).await }; Box::pin(fut) } @@ -1305,7 +2344,7 @@ pub mod msg_server { let inner = self.inner.clone(); let fut = async move { let inner = inner.0; - let method = ChannelOpenInitSvc(inner); + let method = RecvPacketSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1321,23 +2360,23 @@ pub mod msg_server { }; Box::pin(fut) } - "/ibc.core.channel.v1.Msg/ChannelOpenTry" => { + "/ibc.core.channel.v1.Msg/Timeout" => { #[allow(non_camel_case_types)] - struct ChannelOpenTrySvc(pub Arc); - impl tonic::server::UnaryService - for ChannelOpenTrySvc { - type Response = super::MsgChannelOpenTryResponse; + struct TimeoutSvc(pub Arc); + impl tonic::server::UnaryService + for TimeoutSvc { + type Response = super::MsgTimeoutResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::channel_open_try(&inner, request).await + ::timeout(&inner, request).await }; Box::pin(fut) } @@ -1349,7 +2388,7 @@ pub mod msg_server { let inner = self.inner.clone(); let fut = async move { let inner = inner.0; - let method = ChannelOpenTrySvc(inner); + let method = TimeoutSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1365,23 +2404,23 @@ pub mod msg_server { }; Box::pin(fut) } - "/ibc.core.channel.v1.Msg/ChannelOpenAck" => { + "/ibc.core.channel.v1.Msg/TimeoutOnClose" => { #[allow(non_camel_case_types)] - struct ChannelOpenAckSvc(pub Arc); - impl tonic::server::UnaryService - for ChannelOpenAckSvc { - type Response = super::MsgChannelOpenAckResponse; + struct TimeoutOnCloseSvc(pub Arc); + impl tonic::server::UnaryService + for TimeoutOnCloseSvc { + type Response = super::MsgTimeoutOnCloseResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::channel_open_ack(&inner, request).await + ::timeout_on_close(&inner, request).await }; Box::pin(fut) } @@ -1393,7 +2432,7 @@ pub mod msg_server { let inner = self.inner.clone(); let fut = async move { let inner = inner.0; - let method = ChannelOpenAckSvc(inner); + let method = TimeoutOnCloseSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1409,25 +2448,69 @@ pub mod msg_server { }; Box::pin(fut) } - "/ibc.core.channel.v1.Msg/ChannelOpenConfirm" => { + "/ibc.core.channel.v1.Msg/Acknowledgement" => { #[allow(non_camel_case_types)] - struct ChannelOpenConfirmSvc(pub Arc); + struct AcknowledgementSvc(pub Arc); + impl tonic::server::UnaryService + for AcknowledgementSvc { + type Response = super::MsgAcknowledgementResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::acknowledgement(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = 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) + } + "/ibc.core.channel.v1.Msg/ChannelUpgradeInit" => { + #[allow(non_camel_case_types)] + struct ChannelUpgradeInitSvc(pub Arc); impl< T: Msg, - > tonic::server::UnaryService - for ChannelOpenConfirmSvc { - type Response = super::MsgChannelOpenConfirmResponse; + > tonic::server::UnaryService + for ChannelUpgradeInitSvc { + type Response = super::MsgChannelUpgradeInitResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::channel_open_confirm(&inner, request).await + ::channel_upgrade_init(&inner, request).await }; Box::pin(fut) } @@ -1439,7 +2522,7 @@ pub mod msg_server { let inner = self.inner.clone(); let fut = async move { let inner = inner.0; - let method = ChannelOpenConfirmSvc(inner); + let method = ChannelUpgradeInitSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1455,23 +2538,23 @@ pub mod msg_server { }; Box::pin(fut) } - "/ibc.core.channel.v1.Msg/ChannelCloseInit" => { + "/ibc.core.channel.v1.Msg/ChannelUpgradeTry" => { #[allow(non_camel_case_types)] - struct ChannelCloseInitSvc(pub Arc); - impl tonic::server::UnaryService - for ChannelCloseInitSvc { - type Response = super::MsgChannelCloseInitResponse; + struct ChannelUpgradeTrySvc(pub Arc); + impl tonic::server::UnaryService + for ChannelUpgradeTrySvc { + type Response = super::MsgChannelUpgradeTryResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::channel_close_init(&inner, request).await + ::channel_upgrade_try(&inner, request).await }; Box::pin(fut) } @@ -1483,7 +2566,7 @@ pub mod msg_server { let inner = self.inner.clone(); let fut = async move { let inner = inner.0; - let method = ChannelCloseInitSvc(inner); + let method = ChannelUpgradeTrySvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1499,25 +2582,69 @@ pub mod msg_server { }; Box::pin(fut) } - "/ibc.core.channel.v1.Msg/ChannelCloseConfirm" => { + "/ibc.core.channel.v1.Msg/ChannelUpgradeAck" => { #[allow(non_camel_case_types)] - struct ChannelCloseConfirmSvc(pub Arc); + struct ChannelUpgradeAckSvc(pub Arc); + impl tonic::server::UnaryService + for ChannelUpgradeAckSvc { + type Response = super::MsgChannelUpgradeAckResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::channel_upgrade_ack(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ChannelUpgradeAckSvc(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/ChannelUpgradeConfirm" => { + #[allow(non_camel_case_types)] + struct ChannelUpgradeConfirmSvc(pub Arc); impl< T: Msg, - > tonic::server::UnaryService - for ChannelCloseConfirmSvc { - type Response = super::MsgChannelCloseConfirmResponse; + > tonic::server::UnaryService + for ChannelUpgradeConfirmSvc { + type Response = super::MsgChannelUpgradeConfirmResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::channel_close_confirm(&inner, request).await + ::channel_upgrade_confirm(&inner, request).await }; Box::pin(fut) } @@ -1529,7 +2656,7 @@ pub mod msg_server { let inner = self.inner.clone(); let fut = async move { let inner = inner.0; - let method = ChannelCloseConfirmSvc(inner); + let method = ChannelUpgradeConfirmSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1545,23 +2672,25 @@ pub mod msg_server { }; Box::pin(fut) } - "/ibc.core.channel.v1.Msg/RecvPacket" => { + "/ibc.core.channel.v1.Msg/ChannelUpgradeOpen" => { #[allow(non_camel_case_types)] - struct RecvPacketSvc(pub Arc); - impl tonic::server::UnaryService - for RecvPacketSvc { - type Response = super::MsgRecvPacketResponse; + struct ChannelUpgradeOpenSvc(pub Arc); + impl< + T: Msg, + > tonic::server::UnaryService + for ChannelUpgradeOpenSvc { + type Response = super::MsgChannelUpgradeOpenResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::recv_packet(&inner, request).await + ::channel_upgrade_open(&inner, request).await }; Box::pin(fut) } @@ -1573,7 +2702,7 @@ pub mod msg_server { let inner = self.inner.clone(); let fut = async move { let inner = inner.0; - let method = RecvPacketSvc(inner); + let method = ChannelUpgradeOpenSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1589,23 +2718,25 @@ pub mod msg_server { }; Box::pin(fut) } - "/ibc.core.channel.v1.Msg/Timeout" => { + "/ibc.core.channel.v1.Msg/ChannelUpgradeTimeout" => { #[allow(non_camel_case_types)] - struct TimeoutSvc(pub Arc); - impl tonic::server::UnaryService - for TimeoutSvc { - type Response = super::MsgTimeoutResponse; + struct ChannelUpgradeTimeoutSvc(pub Arc); + impl< + T: Msg, + > tonic::server::UnaryService + for ChannelUpgradeTimeoutSvc { + type Response = super::MsgChannelUpgradeTimeoutResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::timeout(&inner, request).await + ::channel_upgrade_timeout(&inner, request).await }; Box::pin(fut) } @@ -1617,7 +2748,7 @@ pub mod msg_server { let inner = self.inner.clone(); let fut = async move { let inner = inner.0; - let method = TimeoutSvc(inner); + let method = ChannelUpgradeTimeoutSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1633,23 +2764,25 @@ pub mod msg_server { }; Box::pin(fut) } - "/ibc.core.channel.v1.Msg/TimeoutOnClose" => { + "/ibc.core.channel.v1.Msg/ChannelUpgradeCancel" => { #[allow(non_camel_case_types)] - struct TimeoutOnCloseSvc(pub Arc); - impl tonic::server::UnaryService - for TimeoutOnCloseSvc { - type Response = super::MsgTimeoutOnCloseResponse; + struct ChannelUpgradeCancelSvc(pub Arc); + impl< + T: Msg, + > tonic::server::UnaryService + for ChannelUpgradeCancelSvc { + type Response = super::MsgChannelUpgradeCancelResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::timeout_on_close(&inner, request).await + ::channel_upgrade_cancel(&inner, request).await }; Box::pin(fut) } @@ -1661,7 +2794,7 @@ pub mod msg_server { let inner = self.inner.clone(); let fut = async move { let inner = inner.0; - let method = TimeoutOnCloseSvc(inner); + let method = ChannelUpgradeCancelSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1677,23 +2810,23 @@ pub mod msg_server { }; Box::pin(fut) } - "/ibc.core.channel.v1.Msg/Acknowledgement" => { + "/ibc.core.channel.v1.Msg/UpdateChannelParams" => { #[allow(non_camel_case_types)] - struct AcknowledgementSvc(pub Arc); - impl tonic::server::UnaryService - for AcknowledgementSvc { - type Response = super::MsgAcknowledgementResponse; + struct UpdateChannelParamsSvc(pub Arc); + impl tonic::server::UnaryService + for UpdateChannelParamsSvc { + type Response = super::MsgUpdateParamsResponse; type Future = BoxFuture< tonic::Response, tonic::Status, >; fn call( &mut self, - request: tonic::Request, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - ::acknowledgement(&inner, request).await + ::update_channel_params(&inner, request).await }; Box::pin(fut) } @@ -1705,7 +2838,53 @@ pub mod msg_server { let inner = self.inner.clone(); let fut = async move { let inner = inner.0; - let method = AcknowledgementSvc(inner); + let method = UpdateChannelParamsSvc(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/PruneAcknowledgements" => { + #[allow(non_camel_case_types)] + struct PruneAcknowledgementsSvc(pub Arc); + impl< + T: Msg, + > tonic::server::UnaryService + for PruneAcknowledgementsSvc { + type Response = super::MsgPruneAcknowledgementsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::prune_acknowledgements(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = PruneAcknowledgementsSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -2316,7 +3495,7 @@ impl ::prost::Name for QueryNextSequenceReceiveRequest { ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) } } -/// QuerySequenceResponse is the request type for the +/// QuerySequenceResponse is the response type for the /// Query/QueryNextSequenceReceiveResponse RPC method #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -2379,6 +3558,104 @@ impl ::prost::Name for QueryNextSequenceSendResponse { ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) } } +/// QueryUpgradeErrorRequest is the request type for the Query/QueryUpgradeError RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryUpgradeErrorRequest { + #[prost(string, tag = "1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub channel_id: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryUpgradeErrorRequest { + const NAME: &'static str = "QueryUpgradeErrorRequest"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// QueryUpgradeErrorResponse is the response type for the Query/QueryUpgradeError RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryUpgradeErrorResponse { + #[prost(message, optional, tag = "1")] + pub error_receipt: ::core::option::Option, + /// merkle proof of existence + #[prost(bytes = "vec", tag = "2")] + pub proof: ::prost::alloc::vec::Vec, + /// height at which the proof was retrieved + #[prost(message, optional, tag = "3")] + pub proof_height: ::core::option::Option, +} +impl ::prost::Name for QueryUpgradeErrorResponse { + const NAME: &'static str = "QueryUpgradeErrorResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// QueryUpgradeRequest is the request type for the QueryUpgradeRequest RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryUpgradeRequest { + #[prost(string, tag = "1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub channel_id: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryUpgradeRequest { + const NAME: &'static str = "QueryUpgradeRequest"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// QueryUpgradeResponse is the response type for the QueryUpgradeResponse RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryUpgradeResponse { + #[prost(message, optional, tag = "1")] + pub upgrade: ::core::option::Option, + /// merkle proof of existence + #[prost(bytes = "vec", tag = "2")] + pub proof: ::prost::alloc::vec::Vec, + /// height at which the proof was retrieved + #[prost(message, optional, tag = "3")] + pub proof_height: ::core::option::Option, +} +impl ::prost::Name for QueryUpgradeResponse { + const NAME: &'static str = "QueryUpgradeResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// QueryChannelParamsRequest is the request type for the Query/ChannelParams RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryChannelParamsRequest {} +impl ::prost::Name for QueryChannelParamsRequest { + const NAME: &'static str = "QueryChannelParamsRequest"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// QueryChannelParamsResponse is the response type for the Query/ChannelParams RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryChannelParamsResponse { + /// params defines the parameters of the module. + #[prost(message, optional, tag = "1")] + pub params: ::core::option::Option, +} +impl ::prost::Name for QueryChannelParamsResponse { + const NAME: &'static str = "QueryChannelParamsResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// Generated client implementations. #[cfg(feature = "client")] pub mod query_client { @@ -2861,6 +4138,84 @@ pub mod query_client { ); self.inner.unary(req, path, codec).await } + /// UpgradeError returns the error receipt if the upgrade handshake failed. + pub async fn upgrade_error( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.core.channel.v1.Query/UpgradeError", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("ibc.core.channel.v1.Query", "UpgradeError")); + self.inner.unary(req, path, codec).await + } + /// Upgrade returns the upgrade for a given port and channel id. + pub async fn upgrade( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.core.channel.v1.Query/Upgrade", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("ibc.core.channel.v1.Query", "Upgrade")); + self.inner.unary(req, path, codec).await + } + /// ChannelParams queries all parameters of the ibc channel submodule. + pub async fn channel_params( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.core.channel.v1.Query/ChannelParams", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("ibc.core.channel.v1.Query", "ChannelParams")); + self.inner.unary(req, path, codec).await + } } } /// Generated server implementations. @@ -2991,6 +4346,30 @@ pub mod query_server { tonic::Response, tonic::Status, >; + /// UpgradeError returns the error receipt if the upgrade handshake failed. + async fn upgrade_error( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Upgrade returns the upgrade for a given port and channel id. + async fn upgrade( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// ChannelParams queries all parameters of the ibc channel submodule. + async fn channel_params( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; } /// Query provides defines the gRPC querier service #[derive(Debug)] @@ -3731,6 +5110,144 @@ pub mod query_server { }; Box::pin(fut) } + "/ibc.core.channel.v1.Query/UpgradeError" => { + #[allow(non_camel_case_types)] + struct UpgradeErrorSvc(pub Arc); + impl< + T: Query, + > tonic::server::UnaryService + for UpgradeErrorSvc { + type Response = super::QueryUpgradeErrorResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::upgrade_error(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = UpgradeErrorSvc(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/Upgrade" => { + #[allow(non_camel_case_types)] + struct UpgradeSvc(pub Arc); + impl< + T: Query, + > tonic::server::UnaryService + for UpgradeSvc { + type Response = super::QueryUpgradeResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::upgrade(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = UpgradeSvc(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/ChannelParams" => { + #[allow(non_camel_case_types)] + struct ChannelParamsSvc(pub Arc); + impl< + T: Query, + > tonic::server::UnaryService + for ChannelParamsSvc { + type Response = super::QueryChannelParamsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::channel_params(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ChannelParamsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } _ => { Box::pin(async move { Ok( diff --git a/src/prost/ibc.core.channel.v1.serde.rs b/src/prost/ibc.core.channel.v1.serde.rs index 1bf7c67..abb6af8 100644 --- a/src/prost/ibc.core.channel.v1.serde.rs +++ b/src/prost/ibc.core.channel.v1.serde.rs @@ -129,6 +129,9 @@ impl serde::Serialize for Channel { if true { len += 1; } + if true { + len += 1; + } let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.Channel", len)?; if true { let v = State::try_from(self.state) @@ -149,6 +152,10 @@ impl serde::Serialize for Channel { if true { struct_ser.serialize_field("version", &self.version)?; } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("upgradeSequence", ::alloc::string::ToString::to_string(&self.upgrade_sequence).as_str())?; + } struct_ser.end() } } @@ -165,6 +172,8 @@ impl<'de> serde::Deserialize<'de> for Channel { "connection_hops", "connectionHops", "version", + "upgrade_sequence", + "upgradeSequence", ]; #[allow(clippy::enum_variant_names)] @@ -174,6 +183,7 @@ impl<'de> serde::Deserialize<'de> for Channel { Counterparty, ConnectionHops, Version, + UpgradeSequence, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -200,6 +210,7 @@ impl<'de> serde::Deserialize<'de> for Channel { "counterparty" => Ok(GeneratedField::Counterparty), "connectionHops" | "connection_hops" => Ok(GeneratedField::ConnectionHops), "version" => Ok(GeneratedField::Version), + "upgradeSequence" | "upgrade_sequence" => Ok(GeneratedField::UpgradeSequence), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -224,6 +235,7 @@ impl<'de> serde::Deserialize<'de> for Channel { let mut counterparty__ = None; let mut connection_hops__ = None; let mut version__ = None; + let mut upgrade_sequence__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::State => { @@ -256,6 +268,14 @@ impl<'de> serde::Deserialize<'de> for Channel { } version__ = Some(map_.next_value()?); } + GeneratedField::UpgradeSequence => { + if upgrade_sequence__.is_some() { + return Err(serde::de::Error::duplicate_field("upgradeSequence")); + } + upgrade_sequence__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } } } Ok(Channel { @@ -264,6 +284,7 @@ impl<'de> serde::Deserialize<'de> for Channel { counterparty: counterparty__, connection_hops: connection_hops__.unwrap_or_default(), version: version__.unwrap_or_default(), + upgrade_sequence: upgrade_sequence__.unwrap_or_default(), }) } } @@ -380,6 +401,117 @@ impl<'de> serde::Deserialize<'de> for Counterparty { deserializer.deserialize_struct("ibc.core.channel.v1.Counterparty", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for ErrorReceipt { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.ErrorReceipt", len)?; + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?; + } + if true { + struct_ser.serialize_field("message", &self.message)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ErrorReceipt { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "sequence", + "message", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Sequence, + Message, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "sequence" => Ok(GeneratedField::Sequence), + "message" => Ok(GeneratedField::Message), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ErrorReceipt; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.ErrorReceipt") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut sequence__ = None; + let mut message__ = 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::Message => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("message")); + } + message__ = Some(map_.next_value()?); + } + } + } + Ok(ErrorReceipt { + sequence: sequence__.unwrap_or_default(), + message: message__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.ErrorReceipt", FIELDS, GeneratedVisitor) + } +} impl serde::Serialize for GenesisState { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result @@ -412,6 +544,9 @@ impl serde::Serialize for GenesisState { if true { len += 1; } + if true { + len += 1; + } let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.GenesisState", len)?; if true { struct_ser.serialize_field("channels", &self.channels)?; @@ -438,6 +573,9 @@ impl serde::Serialize for GenesisState { #[allow(clippy::needless_borrow)] struct_ser.serialize_field("nextChannelSequence", ::alloc::string::ToString::to_string(&self.next_channel_sequence).as_str())?; } + if let Some(v) = self.params.as_ref() { + struct_ser.serialize_field("params", v)?; + } struct_ser.end() } } @@ -460,6 +598,7 @@ impl<'de> serde::Deserialize<'de> for GenesisState { "ackSequences", "next_channel_sequence", "nextChannelSequence", + "params", ]; #[allow(clippy::enum_variant_names)] @@ -472,6 +611,7 @@ impl<'de> serde::Deserialize<'de> for GenesisState { RecvSequences, AckSequences, NextChannelSequence, + Params, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -501,6 +641,7 @@ impl<'de> serde::Deserialize<'de> for GenesisState { "recvSequences" | "recv_sequences" => Ok(GeneratedField::RecvSequences), "ackSequences" | "ack_sequences" => Ok(GeneratedField::AckSequences), "nextChannelSequence" | "next_channel_sequence" => Ok(GeneratedField::NextChannelSequence), + "params" => Ok(GeneratedField::Params), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -528,6 +669,7 @@ impl<'de> serde::Deserialize<'de> for GenesisState { let mut recv_sequences__ = None; let mut ack_sequences__ = None; let mut next_channel_sequence__ = None; + let mut params__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::Channels => { @@ -580,6 +722,12 @@ impl<'de> serde::Deserialize<'de> for GenesisState { 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 { @@ -591,6 +739,7 @@ impl<'de> serde::Deserialize<'de> for GenesisState { recv_sequences: recv_sequences__.unwrap_or_default(), ack_sequences: ack_sequences__.unwrap_or_default(), next_channel_sequence: next_channel_sequence__.unwrap_or_default(), + params: params__, }) } } @@ -626,6 +775,9 @@ impl serde::Serialize for IdentifiedChannel { if true { len += 1; } + if true { + len += 1; + } let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.IdentifiedChannel", len)?; if true { let v = State::try_from(self.state) @@ -652,6 +804,10 @@ impl serde::Serialize for IdentifiedChannel { if true { struct_ser.serialize_field("channelId", &self.channel_id)?; } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("upgradeSequence", ::alloc::string::ToString::to_string(&self.upgrade_sequence).as_str())?; + } struct_ser.end() } } @@ -672,6 +828,8 @@ impl<'de> serde::Deserialize<'de> for IdentifiedChannel { "portId", "channel_id", "channelId", + "upgrade_sequence", + "upgradeSequence", ]; #[allow(clippy::enum_variant_names)] @@ -683,6 +841,7 @@ impl<'de> serde::Deserialize<'de> for IdentifiedChannel { Version, PortId, ChannelId, + UpgradeSequence, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -711,6 +870,7 @@ impl<'de> serde::Deserialize<'de> for IdentifiedChannel { "version" => Ok(GeneratedField::Version), "portId" | "port_id" => Ok(GeneratedField::PortId), "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), + "upgradeSequence" | "upgrade_sequence" => Ok(GeneratedField::UpgradeSequence), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -737,6 +897,7 @@ impl<'de> serde::Deserialize<'de> for IdentifiedChannel { let mut version__ = None; let mut port_id__ = None; let mut channel_id__ = None; + let mut upgrade_sequence__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::State => { @@ -781,6 +942,14 @@ impl<'de> serde::Deserialize<'de> for IdentifiedChannel { } channel_id__ = Some(map_.next_value()?); } + GeneratedField::UpgradeSequence => { + if upgrade_sequence__.is_some() { + return Err(serde::de::Error::duplicate_field("upgradeSequence")); + } + upgrade_sequence__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } } } Ok(IdentifiedChannel { @@ -791,6 +960,7 @@ impl<'de> serde::Deserialize<'de> for IdentifiedChannel { version: version__.unwrap_or_default(), port_id: port_id__.unwrap_or_default(), channel_id: channel_id__.unwrap_or_default(), + upgrade_sequence: upgrade_sequence__.unwrap_or_default(), }) } } @@ -1080,6 +1250,9 @@ impl serde::Serialize for MsgChannelCloseConfirm { if true { len += 1; } + if true { + len += 1; + } let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgChannelCloseConfirm", len)?; if true { struct_ser.serialize_field("portId", &self.port_id)?; @@ -1097,6 +1270,10 @@ impl serde::Serialize for MsgChannelCloseConfirm { if true { struct_ser.serialize_field("signer", &self.signer)?; } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("counterpartyUpgradeSequence", ::alloc::string::ToString::to_string(&self.counterparty_upgrade_sequence).as_str())?; + } struct_ser.end() } } @@ -1116,6 +1293,8 @@ impl<'de> serde::Deserialize<'de> for MsgChannelCloseConfirm { "proof_height", "proofHeight", "signer", + "counterparty_upgrade_sequence", + "counterpartyUpgradeSequence", ]; #[allow(clippy::enum_variant_names)] @@ -1125,6 +1304,7 @@ impl<'de> serde::Deserialize<'de> for MsgChannelCloseConfirm { ProofInit, ProofHeight, Signer, + CounterpartyUpgradeSequence, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -1151,6 +1331,7 @@ impl<'de> serde::Deserialize<'de> for MsgChannelCloseConfirm { "proofInit" | "proof_init" => Ok(GeneratedField::ProofInit), "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight), "signer" => Ok(GeneratedField::Signer), + "counterpartyUpgradeSequence" | "counterparty_upgrade_sequence" => Ok(GeneratedField::CounterpartyUpgradeSequence), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -1175,6 +1356,7 @@ impl<'de> serde::Deserialize<'de> for MsgChannelCloseConfirm { let mut proof_init__ = None; let mut proof_height__ = None; let mut signer__ = None; + let mut counterparty_upgrade_sequence__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::PortId => { @@ -1209,6 +1391,14 @@ impl<'de> serde::Deserialize<'de> for MsgChannelCloseConfirm { } signer__ = Some(map_.next_value()?); } + GeneratedField::CounterpartyUpgradeSequence => { + if counterparty_upgrade_sequence__.is_some() { + return Err(serde::de::Error::duplicate_field("counterpartyUpgradeSequence")); + } + counterparty_upgrade_sequence__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } } } Ok(MsgChannelCloseConfirm { @@ -1217,6 +1407,7 @@ impl<'de> serde::Deserialize<'de> for MsgChannelCloseConfirm { proof_init: proof_init__.unwrap_or_default(), proof_height: proof_height__, signer: signer__.unwrap_or_default(), + counterparty_upgrade_sequence: counterparty_upgrade_sequence__.unwrap_or_default(), }) } } @@ -2547,7 +2738,7 @@ impl<'de> serde::Deserialize<'de> for MsgChannelOpenTryResponse { deserializer.deserialize_struct("ibc.core.channel.v1.MsgChannelOpenTryResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for MsgRecvPacket { +impl serde::Serialize for MsgChannelUpgradeAck { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -2567,13 +2758,32 @@ impl serde::Serialize for MsgRecvPacket { if true { 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 true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgChannelUpgradeAck", len)?; + if true { + struct_ser.serialize_field("portId", &self.port_id)?; + } + if true { + struct_ser.serialize_field("channelId", &self.channel_id)?; + } + if let Some(v) = self.counterparty_upgrade.as_ref() { + struct_ser.serialize_field("counterpartyUpgrade", v)?; } if true { #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("proofCommitment", pbjson::private::base64::encode(&self.proof_commitment).as_str())?; + struct_ser.serialize_field("proofChannel", pbjson::private::base64::encode(&self.proof_channel).as_str())?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("proofUpgrade", pbjson::private::base64::encode(&self.proof_upgrade).as_str())?; } if let Some(v) = self.proof_height.as_ref() { struct_ser.serialize_field("proofHeight", v)?; @@ -2584,16 +2794,23 @@ impl serde::Serialize for MsgRecvPacket { struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for MsgRecvPacket { +impl<'de> serde::Deserialize<'de> for MsgChannelUpgradeAck { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "packet", - "proof_commitment", - "proofCommitment", + "port_id", + "portId", + "channel_id", + "channelId", + "counterparty_upgrade", + "counterpartyUpgrade", + "proof_channel", + "proofChannel", + "proof_upgrade", + "proofUpgrade", "proof_height", "proofHeight", "signer", @@ -2601,8 +2818,11 @@ impl<'de> serde::Deserialize<'de> for MsgRecvPacket { #[allow(clippy::enum_variant_names)] enum GeneratedField { - Packet, - ProofCommitment, + PortId, + ChannelId, + CounterpartyUpgrade, + ProofChannel, + ProofUpgrade, ProofHeight, Signer, } @@ -2626,8 +2846,11 @@ impl<'de> serde::Deserialize<'de> for MsgRecvPacket { E: serde::de::Error, { match value { - "packet" => Ok(GeneratedField::Packet), - "proofCommitment" | "proof_commitment" => Ok(GeneratedField::ProofCommitment), + "portId" | "port_id" => Ok(GeneratedField::PortId), + "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), + "counterpartyUpgrade" | "counterparty_upgrade" => Ok(GeneratedField::CounterpartyUpgrade), + "proofChannel" | "proof_channel" => Ok(GeneratedField::ProofChannel), + "proofUpgrade" | "proof_upgrade" => Ok(GeneratedField::ProofUpgrade), "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight), "signer" => Ok(GeneratedField::Signer), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), @@ -2639,33 +2862,56 @@ impl<'de> serde::Deserialize<'de> for MsgRecvPacket { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MsgRecvPacket; + type Value = MsgChannelUpgradeAck; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.MsgRecvPacket") + formatter.write_str("struct ibc.core.channel.v1.MsgChannelUpgradeAck") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut packet__ = None; - let mut proof_commitment__ = None; + let mut port_id__ = None; + let mut channel_id__ = None; + let mut counterparty_upgrade__ = None; + let mut proof_channel__ = None; + let mut proof_upgrade__ = 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")); + GeneratedField::PortId => { + if port_id__.is_some() { + return Err(serde::de::Error::duplicate_field("portId")); } - packet__ = map_.next_value()?; + port_id__ = Some(map_.next_value()?); } - GeneratedField::ProofCommitment => { - if proof_commitment__.is_some() { - return Err(serde::de::Error::duplicate_field("proofCommitment")); + GeneratedField::ChannelId => { + if channel_id__.is_some() { + return Err(serde::de::Error::duplicate_field("channelId")); } - proof_commitment__ = + channel_id__ = Some(map_.next_value()?); + } + GeneratedField::CounterpartyUpgrade => { + if counterparty_upgrade__.is_some() { + return Err(serde::de::Error::duplicate_field("counterpartyUpgrade")); + } + counterparty_upgrade__ = map_.next_value()?; + } + GeneratedField::ProofChannel => { + if proof_channel__.is_some() { + return Err(serde::de::Error::duplicate_field("proofChannel")); + } + proof_channel__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::ProofUpgrade => { + if proof_upgrade__.is_some() { + return Err(serde::de::Error::duplicate_field("proofUpgrade")); + } + proof_upgrade__ = Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) ; } @@ -2683,18 +2929,21 @@ impl<'de> serde::Deserialize<'de> for MsgRecvPacket { } } } - Ok(MsgRecvPacket { - packet: packet__, - proof_commitment: proof_commitment__.unwrap_or_default(), + Ok(MsgChannelUpgradeAck { + port_id: port_id__.unwrap_or_default(), + channel_id: channel_id__.unwrap_or_default(), + counterparty_upgrade: counterparty_upgrade__, + proof_channel: proof_channel__.unwrap_or_default(), + proof_upgrade: proof_upgrade__.unwrap_or_default(), proof_height: proof_height__, signer: signer__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.MsgRecvPacket", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.MsgChannelUpgradeAck", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for MsgRecvPacketResponse { +impl serde::Serialize for MsgChannelUpgradeAckResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -2705,7 +2954,7 @@ impl serde::Serialize for MsgRecvPacketResponse { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgRecvPacketResponse", len)?; + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgChannelUpgradeAckResponse", len)?; if true { let v = ResponseResultType::try_from(self.result) .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.result)))?; @@ -2714,7 +2963,7 @@ impl serde::Serialize for MsgRecvPacketResponse { struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for MsgRecvPacketResponse { +impl<'de> serde::Deserialize<'de> for MsgChannelUpgradeAckResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where @@ -2758,13 +3007,13 @@ impl<'de> serde::Deserialize<'de> for MsgRecvPacketResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MsgRecvPacketResponse; + type Value = MsgChannelUpgradeAckResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.MsgRecvPacketResponse") + formatter.write_str("struct ibc.core.channel.v1.MsgChannelUpgradeAckResponse") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { @@ -2779,15 +3028,15 @@ impl<'de> serde::Deserialize<'de> for MsgRecvPacketResponse { } } } - Ok(MsgRecvPacketResponse { + Ok(MsgChannelUpgradeAckResponse { result: result__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.MsgRecvPacketResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.MsgChannelUpgradeAckResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for MsgTimeout { +impl serde::Serialize for MsgChannelUpgradeCancel { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -2810,20 +3059,25 @@ impl serde::Serialize for MsgTimeout { if true { 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 true { + len += 1; } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgChannelUpgradeCancel", len)?; if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("proofUnreceived", pbjson::private::base64::encode(&self.proof_unreceived).as_str())?; + struct_ser.serialize_field("portId", &self.port_id)?; } - if let Some(v) = self.proof_height.as_ref() { - struct_ser.serialize_field("proofHeight", v)?; + if true { + struct_ser.serialize_field("channelId", &self.channel_id)?; + } + if let Some(v) = self.error_receipt.as_ref() { + struct_ser.serialize_field("errorReceipt", v)?; } if true { #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("nextSequenceRecv", ::alloc::string::ToString::to_string(&self.next_sequence_recv).as_str())?; + struct_ser.serialize_field("proofErrorReceipt", pbjson::private::base64::encode(&self.proof_error_receipt).as_str())?; + } + if let Some(v) = self.proof_height.as_ref() { + struct_ser.serialize_field("proofHeight", v)?; } if true { struct_ser.serialize_field("signer", &self.signer)?; @@ -2831,29 +3085,33 @@ impl serde::Serialize for MsgTimeout { struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for MsgTimeout { +impl<'de> serde::Deserialize<'de> for MsgChannelUpgradeCancel { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "packet", - "proof_unreceived", - "proofUnreceived", + "port_id", + "portId", + "channel_id", + "channelId", + "error_receipt", + "errorReceipt", + "proof_error_receipt", + "proofErrorReceipt", "proof_height", "proofHeight", - "next_sequence_recv", - "nextSequenceRecv", "signer", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Packet, - ProofUnreceived, + PortId, + ChannelId, + ErrorReceipt, + ProofErrorReceipt, ProofHeight, - NextSequenceRecv, Signer, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -2876,10 +3134,11 @@ impl<'de> serde::Deserialize<'de> for MsgTimeout { E: serde::de::Error, { match value { - "packet" => Ok(GeneratedField::Packet), - "proofUnreceived" | "proof_unreceived" => Ok(GeneratedField::ProofUnreceived), + "portId" | "port_id" => Ok(GeneratedField::PortId), + "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), + "errorReceipt" | "error_receipt" => Ok(GeneratedField::ErrorReceipt), + "proofErrorReceipt" | "proof_error_receipt" => Ok(GeneratedField::ProofErrorReceipt), "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)), } @@ -2890,34 +3149,47 @@ impl<'de> serde::Deserialize<'de> for MsgTimeout { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MsgTimeout; + type Value = MsgChannelUpgradeCancel; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.MsgTimeout") + formatter.write_str("struct ibc.core.channel.v1.MsgChannelUpgradeCancel") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut packet__ = None; - let mut proof_unreceived__ = None; + let mut port_id__ = None; + let mut channel_id__ = None; + let mut error_receipt__ = None; + let mut proof_error_receipt__ = 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")); + GeneratedField::PortId => { + if port_id__.is_some() { + return Err(serde::de::Error::duplicate_field("portId")); } - packet__ = map_.next_value()?; + port_id__ = Some(map_.next_value()?); } - GeneratedField::ProofUnreceived => { - if proof_unreceived__.is_some() { - return Err(serde::de::Error::duplicate_field("proofUnreceived")); + GeneratedField::ChannelId => { + if channel_id__.is_some() { + return Err(serde::de::Error::duplicate_field("channelId")); } - proof_unreceived__ = + channel_id__ = Some(map_.next_value()?); + } + GeneratedField::ErrorReceipt => { + if error_receipt__.is_some() { + return Err(serde::de::Error::duplicate_field("errorReceipt")); + } + error_receipt__ = map_.next_value()?; + } + GeneratedField::ProofErrorReceipt => { + if proof_error_receipt__.is_some() { + return Err(serde::de::Error::duplicate_field("proofErrorReceipt")); + } + proof_error_receipt__ = Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) ; } @@ -2927,14 +3199,6 @@ impl<'de> serde::Deserialize<'de> for MsgTimeout { } 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")); @@ -2943,19 +3207,91 @@ impl<'de> serde::Deserialize<'de> for MsgTimeout { } } } - Ok(MsgTimeout { - packet: packet__, - proof_unreceived: proof_unreceived__.unwrap_or_default(), + Ok(MsgChannelUpgradeCancel { + port_id: port_id__.unwrap_or_default(), + channel_id: channel_id__.unwrap_or_default(), + error_receipt: error_receipt__, + proof_error_receipt: proof_error_receipt__.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) + deserializer.deserialize_struct("ibc.core.channel.v1.MsgChannelUpgradeCancel", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for MsgTimeoutOnClose { +impl serde::Serialize for MsgChannelUpgradeCancelResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgChannelUpgradeCancelResponse", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgChannelUpgradeCancelResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgChannelUpgradeCancelResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.MsgChannelUpgradeCancelResponse") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(MsgChannelUpgradeCancelResponse { + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.MsgChannelUpgradeCancelResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MsgChannelUpgradeConfirm { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -2981,57 +3317,77 @@ impl serde::Serialize for MsgTimeoutOnClose { if true { 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 true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgChannelUpgradeConfirm", len)?; + if true { + struct_ser.serialize_field("portId", &self.port_id)?; + } + if true { + struct_ser.serialize_field("channelId", &self.channel_id)?; + } + if true { + let v = State::try_from(self.counterparty_channel_state) + .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.counterparty_channel_state)))?; + struct_ser.serialize_field("counterpartyChannelState", &v)?; + } + if let Some(v) = self.counterparty_upgrade.as_ref() { + struct_ser.serialize_field("counterpartyUpgrade", v)?; } if true { #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("proofUnreceived", pbjson::private::base64::encode(&self.proof_unreceived).as_str())?; + struct_ser.serialize_field("proofChannel", pbjson::private::base64::encode(&self.proof_channel).as_str())?; } if true { #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("proofClose", pbjson::private::base64::encode(&self.proof_close).as_str())?; + struct_ser.serialize_field("proofUpgrade", pbjson::private::base64::encode(&self.proof_upgrade).as_str())?; } if let Some(v) = self.proof_height.as_ref() { struct_ser.serialize_field("proofHeight", v)?; } - if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("nextSequenceRecv", ::alloc::string::ToString::to_string(&self.next_sequence_recv).as_str())?; - } if true { struct_ser.serialize_field("signer", &self.signer)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for MsgTimeoutOnClose { +impl<'de> serde::Deserialize<'de> for MsgChannelUpgradeConfirm { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "packet", - "proof_unreceived", - "proofUnreceived", - "proof_close", - "proofClose", + "port_id", + "portId", + "channel_id", + "channelId", + "counterparty_channel_state", + "counterpartyChannelState", + "counterparty_upgrade", + "counterpartyUpgrade", + "proof_channel", + "proofChannel", + "proof_upgrade", + "proofUpgrade", "proof_height", "proofHeight", - "next_sequence_recv", - "nextSequenceRecv", "signer", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Packet, - ProofUnreceived, - ProofClose, + PortId, + ChannelId, + CounterpartyChannelState, + CounterpartyUpgrade, + ProofChannel, + ProofUpgrade, ProofHeight, - NextSequenceRecv, Signer, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -3054,11 +3410,13 @@ impl<'de> serde::Deserialize<'de> for MsgTimeoutOnClose { E: serde::de::Error, { match value { - "packet" => Ok(GeneratedField::Packet), - "proofUnreceived" | "proof_unreceived" => Ok(GeneratedField::ProofUnreceived), - "proofClose" | "proof_close" => Ok(GeneratedField::ProofClose), + "portId" | "port_id" => Ok(GeneratedField::PortId), + "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), + "counterpartyChannelState" | "counterparty_channel_state" => Ok(GeneratedField::CounterpartyChannelState), + "counterpartyUpgrade" | "counterparty_upgrade" => Ok(GeneratedField::CounterpartyUpgrade), + "proofChannel" | "proof_channel" => Ok(GeneratedField::ProofChannel), + "proofUpgrade" | "proof_upgrade" => Ok(GeneratedField::ProofUpgrade), "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)), } @@ -3069,43 +3427,63 @@ impl<'de> serde::Deserialize<'de> for MsgTimeoutOnClose { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MsgTimeoutOnClose; + type Value = MsgChannelUpgradeConfirm; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.MsgTimeoutOnClose") + formatter.write_str("struct ibc.core.channel.v1.MsgChannelUpgradeConfirm") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut packet__ = None; - let mut proof_unreceived__ = None; - let mut proof_close__ = None; + let mut port_id__ = None; + let mut channel_id__ = None; + let mut counterparty_channel_state__ = None; + let mut counterparty_upgrade__ = None; + let mut proof_channel__ = None; + let mut proof_upgrade__ = 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")); + GeneratedField::PortId => { + if port_id__.is_some() { + return Err(serde::de::Error::duplicate_field("portId")); } - packet__ = map_.next_value()?; + port_id__ = Some(map_.next_value()?); } - GeneratedField::ProofUnreceived => { - if proof_unreceived__.is_some() { - return Err(serde::de::Error::duplicate_field("proofUnreceived")); + GeneratedField::ChannelId => { + if channel_id__.is_some() { + return Err(serde::de::Error::duplicate_field("channelId")); } - proof_unreceived__ = + channel_id__ = Some(map_.next_value()?); + } + GeneratedField::CounterpartyChannelState => { + if counterparty_channel_state__.is_some() { + return Err(serde::de::Error::duplicate_field("counterpartyChannelState")); + } + counterparty_channel_state__ = Some(map_.next_value::()? as i32); + } + GeneratedField::CounterpartyUpgrade => { + if counterparty_upgrade__.is_some() { + return Err(serde::de::Error::duplicate_field("counterpartyUpgrade")); + } + counterparty_upgrade__ = map_.next_value()?; + } + GeneratedField::ProofChannel => { + if proof_channel__.is_some() { + return Err(serde::de::Error::duplicate_field("proofChannel")); + } + proof_channel__ = Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) ; } - GeneratedField::ProofClose => { - if proof_close__.is_some() { - return Err(serde::de::Error::duplicate_field("proofClose")); + GeneratedField::ProofUpgrade => { + if proof_upgrade__.is_some() { + return Err(serde::de::Error::duplicate_field("proofUpgrade")); } - proof_close__ = + proof_upgrade__ = Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) ; } @@ -3115,14 +3493,6 @@ impl<'de> serde::Deserialize<'de> for MsgTimeoutOnClose { } 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")); @@ -3131,20 +3501,22 @@ impl<'de> serde::Deserialize<'de> for MsgTimeoutOnClose { } } } - Ok(MsgTimeoutOnClose { - packet: packet__, - proof_unreceived: proof_unreceived__.unwrap_or_default(), - proof_close: proof_close__.unwrap_or_default(), + Ok(MsgChannelUpgradeConfirm { + port_id: port_id__.unwrap_or_default(), + channel_id: channel_id__.unwrap_or_default(), + counterparty_channel_state: counterparty_channel_state__.unwrap_or_default(), + counterparty_upgrade: counterparty_upgrade__, + proof_channel: proof_channel__.unwrap_or_default(), + proof_upgrade: proof_upgrade__.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) + deserializer.deserialize_struct("ibc.core.channel.v1.MsgChannelUpgradeConfirm", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for MsgTimeoutOnCloseResponse { +impl serde::Serialize for MsgChannelUpgradeConfirmResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -3155,7 +3527,7 @@ impl serde::Serialize for MsgTimeoutOnCloseResponse { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgTimeoutOnCloseResponse", len)?; + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgChannelUpgradeConfirmResponse", len)?; if true { let v = ResponseResultType::try_from(self.result) .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.result)))?; @@ -3164,7 +3536,7 @@ impl serde::Serialize for MsgTimeoutOnCloseResponse { struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for MsgTimeoutOnCloseResponse { +impl<'de> serde::Deserialize<'de> for MsgChannelUpgradeConfirmResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where @@ -3208,13 +3580,13 @@ impl<'de> serde::Deserialize<'de> for MsgTimeoutOnCloseResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MsgTimeoutOnCloseResponse; + type Value = MsgChannelUpgradeConfirmResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.MsgTimeoutOnCloseResponse") + formatter.write_str("struct ibc.core.channel.v1.MsgChannelUpgradeConfirmResponse") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { @@ -3229,15 +3601,15 @@ impl<'de> serde::Deserialize<'de> for MsgTimeoutOnCloseResponse { } } } - Ok(MsgTimeoutOnCloseResponse { + Ok(MsgChannelUpgradeConfirmResponse { result: result__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.MsgTimeoutOnCloseResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.MsgChannelUpgradeConfirmResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for MsgTimeoutResponse { +impl serde::Serialize for MsgChannelUpgradeInit { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -3248,28 +3620,52 @@ impl serde::Serialize for MsgTimeoutResponse { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgTimeoutResponse", len)?; if true { - let v = ResponseResultType::try_from(self.result) - .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.result)))?; - struct_ser.serialize_field("result", &v)?; + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgChannelUpgradeInit", len)?; + if true { + struct_ser.serialize_field("portId", &self.port_id)?; + } + if true { + struct_ser.serialize_field("channelId", &self.channel_id)?; + } + if let Some(v) = self.fields.as_ref() { + struct_ser.serialize_field("fields", v)?; + } + if true { + struct_ser.serialize_field("signer", &self.signer)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for MsgTimeoutResponse { +impl<'de> serde::Deserialize<'de> for MsgChannelUpgradeInit { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "result", + "port_id", + "portId", + "channel_id", + "channelId", + "fields", + "signer", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Result, + PortId, + ChannelId, + Fields, + Signer, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -3291,7 +3687,10 @@ impl<'de> serde::Deserialize<'de> for MsgTimeoutResponse { E: serde::de::Error, { match value { - "result" => Ok(GeneratedField::Result), + "portId" | "port_id" => Ok(GeneratedField::PortId), + "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), + "fields" => Ok(GeneratedField::Fields), + "signer" => Ok(GeneratedField::Signer), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -3301,110 +3700,172 @@ impl<'de> serde::Deserialize<'de> for MsgTimeoutResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MsgTimeoutResponse; + type Value = MsgChannelUpgradeInit; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.MsgTimeoutResponse") + formatter.write_str("struct ibc.core.channel.v1.MsgChannelUpgradeInit") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut result__ = None; + let mut port_id__ = None; + let mut channel_id__ = None; + let mut fields__ = None; + let mut signer__ = 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::()? as i32); + 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::Fields => { + if fields__.is_some() { + return Err(serde::de::Error::duplicate_field("fields")); + } + fields__ = map_.next_value()?; + } + GeneratedField::Signer => { + if signer__.is_some() { + return Err(serde::de::Error::duplicate_field("signer")); + } + signer__ = Some(map_.next_value()?); } } } - Ok(MsgTimeoutResponse { - result: result__.unwrap_or_default(), + Ok(MsgChannelUpgradeInit { + port_id: port_id__.unwrap_or_default(), + channel_id: channel_id__.unwrap_or_default(), + fields: fields__, + signer: signer__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.MsgTimeoutResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.MsgChannelUpgradeInit", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for Order { +impl serde::Serialize for MsgChannelUpgradeInitResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result 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) + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgChannelUpgradeInitResponse", len)?; + if let Some(v) = self.upgrade.as_ref() { + struct_ser.serialize_field("upgrade", v)?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("upgradeSequence", ::alloc::string::ToString::to_string(&self.upgrade_sequence).as_str())?; + } + struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for Order { +impl<'de> serde::Deserialize<'de> for MsgChannelUpgradeInitResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "ORDER_NONE_UNSPECIFIED", - "ORDER_UNORDERED", - "ORDER_ORDERED", + "upgrade", + "upgrade_sequence", + "upgradeSequence", ]; - struct GeneratedVisitor; + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Upgrade, + UpgradeSequence, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Order; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } - fn visit_i64(self, v: i64) -> core::result::Result - where - E: serde::de::Error, - { - i32::try_from(v) - .ok() - .and_then(|x| x.try_into().ok()) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "upgrade" => Ok(GeneratedField::Upgrade), + "upgradeSequence" | "upgrade_sequence" => Ok(GeneratedField::UpgradeSequence), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgChannelUpgradeInitResponse; - fn visit_u64(self, v: u64) -> core::result::Result - where - E: serde::de::Error, - { - i32::try_from(v) - .ok() - .and_then(|x| x.try_into().ok()) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.MsgChannelUpgradeInitResponse") } - fn visit_str(self, value: &str) -> core::result::Result - where - E: serde::de::Error, + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, { - 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)), + let mut upgrade__ = None; + let mut upgrade_sequence__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Upgrade => { + if upgrade__.is_some() { + return Err(serde::de::Error::duplicate_field("upgrade")); + } + upgrade__ = map_.next_value()?; + } + GeneratedField::UpgradeSequence => { + if upgrade_sequence__.is_some() { + return Err(serde::de::Error::duplicate_field("upgradeSequence")); + } + upgrade_sequence__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } } + Ok(MsgChannelUpgradeInitResponse { + upgrade: upgrade__, + upgrade_sequence: upgrade_sequence__.unwrap_or_default(), + }) } } - deserializer.deserialize_any(GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.MsgChannelUpgradeInitResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for Packet { +impl serde::Serialize for MsgChannelUpgradeOpen { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -3433,73 +3894,66 @@ impl serde::Serialize for Packet { if true { len += 1; } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgChannelUpgradeOpen", len)?; if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.Packet", len)?; - if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?; - } - if true { - struct_ser.serialize_field("sourcePort", &self.source_port)?; + struct_ser.serialize_field("portId", &self.port_id)?; } if true { - struct_ser.serialize_field("sourceChannel", &self.source_channel)?; + struct_ser.serialize_field("channelId", &self.channel_id)?; } if true { - struct_ser.serialize_field("destinationPort", &self.destination_port)?; + let v = State::try_from(self.counterparty_channel_state) + .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.counterparty_channel_state)))?; + struct_ser.serialize_field("counterpartyChannelState", &v)?; } if true { - struct_ser.serialize_field("destinationChannel", &self.destination_channel)?; + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("counterpartyUpgradeSequence", ::alloc::string::ToString::to_string(&self.counterparty_upgrade_sequence).as_str())?; } if true { #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?; + struct_ser.serialize_field("proofChannel", pbjson::private::base64::encode(&self.proof_channel).as_str())?; } - if let Some(v) = self.timeout_height.as_ref() { - struct_ser.serialize_field("timeoutHeight", v)?; + if let Some(v) = self.proof_height.as_ref() { + struct_ser.serialize_field("proofHeight", v)?; } if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("timeoutTimestamp", ::alloc::string::ToString::to_string(&self.timeout_timestamp).as_str())?; + struct_ser.serialize_field("signer", &self.signer)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for Packet { +impl<'de> serde::Deserialize<'de> for MsgChannelUpgradeOpen { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result 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", + "port_id", + "portId", + "channel_id", + "channelId", + "counterparty_channel_state", + "counterpartyChannelState", + "counterparty_upgrade_sequence", + "counterpartyUpgradeSequence", + "proof_channel", + "proofChannel", + "proof_height", + "proofHeight", + "signer", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Sequence, - SourcePort, - SourceChannel, - DestinationPort, - DestinationChannel, - Data, - TimeoutHeight, - TimeoutTimestamp, + PortId, + ChannelId, + CounterpartyChannelState, + CounterpartyUpgradeSequence, + ProofChannel, + ProofHeight, + Signer, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -3521,14 +3975,13 @@ impl<'de> serde::Deserialize<'de> for Packet { 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), + "portId" | "port_id" => Ok(GeneratedField::PortId), + "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), + "counterpartyChannelState" | "counterparty_channel_state" => Ok(GeneratedField::CounterpartyChannelState), + "counterpartyUpgradeSequence" | "counterparty_upgrade_sequence" => Ok(GeneratedField::CounterpartyUpgradeSequence), + "proofChannel" | "proof_channel" => Ok(GeneratedField::ProofChannel), + "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight), + "signer" => Ok(GeneratedField::Signer), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -3538,98 +3991,3076 @@ impl<'de> serde::Deserialize<'de> for Packet { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Packet; + type Value = MsgChannelUpgradeOpen; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.Packet") + formatter.write_str("struct ibc.core.channel.v1.MsgChannelUpgradeOpen") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut 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; + let mut port_id__ = None; + let mut channel_id__ = None; + let mut counterparty_channel_state__ = None; + let mut counterparty_upgrade_sequence__ = None; + let mut proof_channel__ = None; + let mut proof_height__ = None; + let mut signer__ = 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")); + GeneratedField::PortId => { + if port_id__.is_some() { + return Err(serde::de::Error::duplicate_field("portId")); } - source_port__ = Some(map_.next_value()?); + port_id__ = Some(map_.next_value()?); } - GeneratedField::SourceChannel => { - if source_channel__.is_some() { - return Err(serde::de::Error::duplicate_field("sourceChannel")); + GeneratedField::ChannelId => { + if channel_id__.is_some() { + return Err(serde::de::Error::duplicate_field("channelId")); } - source_channel__ = Some(map_.next_value()?); + channel_id__ = Some(map_.next_value()?); } - GeneratedField::DestinationPort => { - if destination_port__.is_some() { - return Err(serde::de::Error::duplicate_field("destinationPort")); + GeneratedField::CounterpartyChannelState => { + if counterparty_channel_state__.is_some() { + return Err(serde::de::Error::duplicate_field("counterpartyChannelState")); } - destination_port__ = Some(map_.next_value()?); + counterparty_channel_state__ = Some(map_.next_value::()? as i32); } - GeneratedField::DestinationChannel => { - if destination_channel__.is_some() { - return Err(serde::de::Error::duplicate_field("destinationChannel")); + GeneratedField::CounterpartyUpgradeSequence => { + if counterparty_upgrade_sequence__.is_some() { + return Err(serde::de::Error::duplicate_field("counterpartyUpgradeSequence")); } - destination_channel__ = Some(map_.next_value()?); + counterparty_upgrade_sequence__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::Data => { - if data__.is_some() { - return Err(serde::de::Error::duplicate_field("data")); + GeneratedField::ProofChannel => { + if proof_channel__.is_some() { + return Err(serde::de::Error::duplicate_field("proofChannel")); } - data__ = + proof_channel__ = Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) ; } - GeneratedField::TimeoutHeight => { - if timeout_height__.is_some() { - return Err(serde::de::Error::duplicate_field("timeoutHeight")); + GeneratedField::ProofHeight => { + if proof_height__.is_some() { + return Err(serde::de::Error::duplicate_field("proofHeight")); } - timeout_height__ = map_.next_value()?; + 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(MsgChannelUpgradeOpen { + port_id: port_id__.unwrap_or_default(), + channel_id: channel_id__.unwrap_or_default(), + counterparty_channel_state: counterparty_channel_state__.unwrap_or_default(), + counterparty_upgrade_sequence: counterparty_upgrade_sequence__.unwrap_or_default(), + proof_channel: proof_channel__.unwrap_or_default(), + proof_height: proof_height__, + signer: signer__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.MsgChannelUpgradeOpen", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MsgChannelUpgradeOpenResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgChannelUpgradeOpenResponse", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgChannelUpgradeOpenResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgChannelUpgradeOpenResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.MsgChannelUpgradeOpenResponse") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(MsgChannelUpgradeOpenResponse { + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.MsgChannelUpgradeOpenResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MsgChannelUpgradeTimeout { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgChannelUpgradeTimeout", len)?; + if true { + struct_ser.serialize_field("portId", &self.port_id)?; + } + if true { + struct_ser.serialize_field("channelId", &self.channel_id)?; + } + if let Some(v) = self.counterparty_channel.as_ref() { + struct_ser.serialize_field("counterpartyChannel", v)?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("proofChannel", pbjson::private::base64::encode(&self.proof_channel).as_str())?; + } + if let Some(v) = self.proof_height.as_ref() { + struct_ser.serialize_field("proofHeight", v)?; + } + if true { + struct_ser.serialize_field("signer", &self.signer)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgChannelUpgradeTimeout { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "port_id", + "portId", + "channel_id", + "channelId", + "counterparty_channel", + "counterpartyChannel", + "proof_channel", + "proofChannel", + "proof_height", + "proofHeight", + "signer", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + PortId, + ChannelId, + CounterpartyChannel, + ProofChannel, + ProofHeight, + Signer, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "portId" | "port_id" => Ok(GeneratedField::PortId), + "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), + "counterpartyChannel" | "counterparty_channel" => Ok(GeneratedField::CounterpartyChannel), + "proofChannel" | "proof_channel" => Ok(GeneratedField::ProofChannel), + "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 = MsgChannelUpgradeTimeout; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.MsgChannelUpgradeTimeout") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut port_id__ = None; + let mut channel_id__ = None; + let mut counterparty_channel__ = None; + let mut proof_channel__ = 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::CounterpartyChannel => { + if counterparty_channel__.is_some() { + return Err(serde::de::Error::duplicate_field("counterpartyChannel")); + } + counterparty_channel__ = map_.next_value()?; + } + GeneratedField::ProofChannel => { + if proof_channel__.is_some() { + return Err(serde::de::Error::duplicate_field("proofChannel")); + } + proof_channel__ = + 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(MsgChannelUpgradeTimeout { + port_id: port_id__.unwrap_or_default(), + channel_id: channel_id__.unwrap_or_default(), + counterparty_channel: counterparty_channel__, + proof_channel: proof_channel__.unwrap_or_default(), + proof_height: proof_height__, + signer: signer__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.MsgChannelUpgradeTimeout", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MsgChannelUpgradeTimeoutResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgChannelUpgradeTimeoutResponse", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgChannelUpgradeTimeoutResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgChannelUpgradeTimeoutResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.MsgChannelUpgradeTimeoutResponse") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(MsgChannelUpgradeTimeoutResponse { + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.MsgChannelUpgradeTimeoutResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MsgChannelUpgradeTry { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgChannelUpgradeTry", len)?; + if true { + struct_ser.serialize_field("portId", &self.port_id)?; + } + if true { + struct_ser.serialize_field("channelId", &self.channel_id)?; + } + if true { + struct_ser.serialize_field("proposedUpgradeConnectionHops", &self.proposed_upgrade_connection_hops)?; + } + if let Some(v) = self.counterparty_upgrade_fields.as_ref() { + struct_ser.serialize_field("counterpartyUpgradeFields", v)?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("counterpartyUpgradeSequence", ::alloc::string::ToString::to_string(&self.counterparty_upgrade_sequence).as_str())?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("proofChannel", pbjson::private::base64::encode(&self.proof_channel).as_str())?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("proofUpgrade", pbjson::private::base64::encode(&self.proof_upgrade).as_str())?; + } + if let Some(v) = self.proof_height.as_ref() { + struct_ser.serialize_field("proofHeight", v)?; + } + if true { + struct_ser.serialize_field("signer", &self.signer)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgChannelUpgradeTry { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "port_id", + "portId", + "channel_id", + "channelId", + "proposed_upgrade_connection_hops", + "proposedUpgradeConnectionHops", + "counterparty_upgrade_fields", + "counterpartyUpgradeFields", + "counterparty_upgrade_sequence", + "counterpartyUpgradeSequence", + "proof_channel", + "proofChannel", + "proof_upgrade", + "proofUpgrade", + "proof_height", + "proofHeight", + "signer", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + PortId, + ChannelId, + ProposedUpgradeConnectionHops, + CounterpartyUpgradeFields, + CounterpartyUpgradeSequence, + ProofChannel, + ProofUpgrade, + ProofHeight, + Signer, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "portId" | "port_id" => Ok(GeneratedField::PortId), + "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), + "proposedUpgradeConnectionHops" | "proposed_upgrade_connection_hops" => Ok(GeneratedField::ProposedUpgradeConnectionHops), + "counterpartyUpgradeFields" | "counterparty_upgrade_fields" => Ok(GeneratedField::CounterpartyUpgradeFields), + "counterpartyUpgradeSequence" | "counterparty_upgrade_sequence" => Ok(GeneratedField::CounterpartyUpgradeSequence), + "proofChannel" | "proof_channel" => Ok(GeneratedField::ProofChannel), + "proofUpgrade" | "proof_upgrade" => Ok(GeneratedField::ProofUpgrade), + "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 = MsgChannelUpgradeTry; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.MsgChannelUpgradeTry") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut port_id__ = None; + let mut channel_id__ = None; + let mut proposed_upgrade_connection_hops__ = None; + let mut counterparty_upgrade_fields__ = None; + let mut counterparty_upgrade_sequence__ = None; + let mut proof_channel__ = None; + let mut proof_upgrade__ = 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::ProposedUpgradeConnectionHops => { + if proposed_upgrade_connection_hops__.is_some() { + return Err(serde::de::Error::duplicate_field("proposedUpgradeConnectionHops")); + } + proposed_upgrade_connection_hops__ = Some(map_.next_value()?); + } + GeneratedField::CounterpartyUpgradeFields => { + if counterparty_upgrade_fields__.is_some() { + return Err(serde::de::Error::duplicate_field("counterpartyUpgradeFields")); + } + counterparty_upgrade_fields__ = map_.next_value()?; + } + GeneratedField::CounterpartyUpgradeSequence => { + if counterparty_upgrade_sequence__.is_some() { + return Err(serde::de::Error::duplicate_field("counterpartyUpgradeSequence")); + } + counterparty_upgrade_sequence__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::ProofChannel => { + if proof_channel__.is_some() { + return Err(serde::de::Error::duplicate_field("proofChannel")); + } + proof_channel__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::ProofUpgrade => { + if proof_upgrade__.is_some() { + return Err(serde::de::Error::duplicate_field("proofUpgrade")); + } + proof_upgrade__ = + 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(MsgChannelUpgradeTry { + port_id: port_id__.unwrap_or_default(), + channel_id: channel_id__.unwrap_or_default(), + proposed_upgrade_connection_hops: proposed_upgrade_connection_hops__.unwrap_or_default(), + counterparty_upgrade_fields: counterparty_upgrade_fields__, + counterparty_upgrade_sequence: counterparty_upgrade_sequence__.unwrap_or_default(), + proof_channel: proof_channel__.unwrap_or_default(), + proof_upgrade: proof_upgrade__.unwrap_or_default(), + proof_height: proof_height__, + signer: signer__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.MsgChannelUpgradeTry", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MsgChannelUpgradeTryResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgChannelUpgradeTryResponse", len)?; + if let Some(v) = self.upgrade.as_ref() { + struct_ser.serialize_field("upgrade", v)?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("upgradeSequence", ::alloc::string::ToString::to_string(&self.upgrade_sequence).as_str())?; + } + if true { + let v = ResponseResultType::try_from(self.result) + .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.result)))?; + struct_ser.serialize_field("result", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgChannelUpgradeTryResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "upgrade", + "upgrade_sequence", + "upgradeSequence", + "result", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Upgrade, + UpgradeSequence, + Result, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "upgrade" => Ok(GeneratedField::Upgrade), + "upgradeSequence" | "upgrade_sequence" => Ok(GeneratedField::UpgradeSequence), + "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 = MsgChannelUpgradeTryResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.MsgChannelUpgradeTryResponse") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut upgrade__ = None; + let mut upgrade_sequence__ = None; + let mut result__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Upgrade => { + if upgrade__.is_some() { + return Err(serde::de::Error::duplicate_field("upgrade")); + } + upgrade__ = map_.next_value()?; + } + GeneratedField::UpgradeSequence => { + if upgrade_sequence__.is_some() { + return Err(serde::de::Error::duplicate_field("upgradeSequence")); + } + upgrade_sequence__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Result => { + if result__.is_some() { + return Err(serde::de::Error::duplicate_field("result")); + } + result__ = Some(map_.next_value::()? as i32); + } + } + } + Ok(MsgChannelUpgradeTryResponse { + upgrade: upgrade__, + upgrade_sequence: upgrade_sequence__.unwrap_or_default(), + result: result__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.MsgChannelUpgradeTryResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MsgPruneAcknowledgements { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgPruneAcknowledgements", len)?; + if true { + struct_ser.serialize_field("portId", &self.port_id)?; + } + if true { + struct_ser.serialize_field("channelId", &self.channel_id)?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("limit", ::alloc::string::ToString::to_string(&self.limit).as_str())?; + } + if true { + struct_ser.serialize_field("signer", &self.signer)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgPruneAcknowledgements { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "port_id", + "portId", + "channel_id", + "channelId", + "limit", + "signer", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + PortId, + ChannelId, + Limit, + Signer, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "portId" | "port_id" => Ok(GeneratedField::PortId), + "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), + "limit" => Ok(GeneratedField::Limit), + "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 = MsgPruneAcknowledgements; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.MsgPruneAcknowledgements") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut port_id__ = None; + let mut channel_id__ = None; + let mut limit__ = 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::Limit => { + if limit__.is_some() { + return Err(serde::de::Error::duplicate_field("limit")); + } + limit__ = + 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(MsgPruneAcknowledgements { + port_id: port_id__.unwrap_or_default(), + channel_id: channel_id__.unwrap_or_default(), + limit: limit__.unwrap_or_default(), + signer: signer__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.MsgPruneAcknowledgements", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MsgPruneAcknowledgementsResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgPruneAcknowledgementsResponse", len)?; + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("totalPrunedSequences", ::alloc::string::ToString::to_string(&self.total_pruned_sequences).as_str())?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("totalRemainingSequences", ::alloc::string::ToString::to_string(&self.total_remaining_sequences).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgPruneAcknowledgementsResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "total_pruned_sequences", + "totalPrunedSequences", + "total_remaining_sequences", + "totalRemainingSequences", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + TotalPrunedSequences, + TotalRemainingSequences, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "totalPrunedSequences" | "total_pruned_sequences" => Ok(GeneratedField::TotalPrunedSequences), + "totalRemainingSequences" | "total_remaining_sequences" => Ok(GeneratedField::TotalRemainingSequences), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgPruneAcknowledgementsResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.MsgPruneAcknowledgementsResponse") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut total_pruned_sequences__ = None; + let mut total_remaining_sequences__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::TotalPrunedSequences => { + if total_pruned_sequences__.is_some() { + return Err(serde::de::Error::duplicate_field("totalPrunedSequences")); + } + total_pruned_sequences__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::TotalRemainingSequences => { + if total_remaining_sequences__.is_some() { + return Err(serde::de::Error::duplicate_field("totalRemainingSequences")); + } + total_remaining_sequences__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(MsgPruneAcknowledgementsResponse { + total_pruned_sequences: total_pruned_sequences__.unwrap_or_default(), + total_remaining_sequences: total_remaining_sequences__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.MsgPruneAcknowledgementsResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MsgRecvPacket { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgRecvPacket", len)?; + if let Some(v) = self.packet.as_ref() { + struct_ser.serialize_field("packet", v)?; + } + if true { + #[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 true { + struct_ser.serialize_field("signer", &self.signer)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgRecvPacket { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + 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, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "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 core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.MsgRecvPacket") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + 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) + } +} +impl serde::Serialize for MsgRecvPacketResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgRecvPacketResponse", len)?; + if true { + let v = ResponseResultType::try_from(self.result) + .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.result)))?; + struct_ser.serialize_field("result", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgRecvPacketResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "result", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Result, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "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 core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.MsgRecvPacketResponse") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + 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::()? as i32); + } + } + } + Ok(MsgRecvPacketResponse { + result: result__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.MsgRecvPacketResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MsgTimeout { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgTimeout", len)?; + if let Some(v) = self.packet.as_ref() { + struct_ser.serialize_field("packet", v)?; + } + if true { + #[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 true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("nextSequenceRecv", ::alloc::string::ToString::to_string(&self.next_sequence_recv).as_str())?; + } + if true { + struct_ser.serialize_field("signer", &self.signer)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgTimeout { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + 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, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "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 core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.MsgTimeout") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + 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) + } +} +impl serde::Serialize for MsgTimeoutOnClose { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgTimeoutOnClose", len)?; + if let Some(v) = self.packet.as_ref() { + struct_ser.serialize_field("packet", v)?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("proofUnreceived", pbjson::private::base64::encode(&self.proof_unreceived).as_str())?; + } + if true { + #[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 true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("nextSequenceRecv", ::alloc::string::ToString::to_string(&self.next_sequence_recv).as_str())?; + } + if true { + struct_ser.serialize_field("signer", &self.signer)?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("counterpartyUpgradeSequence", ::alloc::string::ToString::to_string(&self.counterparty_upgrade_sequence).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgTimeoutOnClose { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "packet", + "proof_unreceived", + "proofUnreceived", + "proof_close", + "proofClose", + "proof_height", + "proofHeight", + "next_sequence_recv", + "nextSequenceRecv", + "signer", + "counterparty_upgrade_sequence", + "counterpartyUpgradeSequence", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Packet, + ProofUnreceived, + ProofClose, + ProofHeight, + NextSequenceRecv, + Signer, + CounterpartyUpgradeSequence, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "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), + "counterpartyUpgradeSequence" | "counterparty_upgrade_sequence" => Ok(GeneratedField::CounterpartyUpgradeSequence), + _ => 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 core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.MsgTimeoutOnClose") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + 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; + let mut counterparty_upgrade_sequence__ = 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()?); + } + GeneratedField::CounterpartyUpgradeSequence => { + if counterparty_upgrade_sequence__.is_some() { + return Err(serde::de::Error::duplicate_field("counterpartyUpgradeSequence")); + } + counterparty_upgrade_sequence__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + 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(), + counterparty_upgrade_sequence: counterparty_upgrade_sequence__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.MsgTimeoutOnClose", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MsgTimeoutOnCloseResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgTimeoutOnCloseResponse", len)?; + if true { + let v = ResponseResultType::try_from(self.result) + .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.result)))?; + struct_ser.serialize_field("result", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgTimeoutOnCloseResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "result", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Result, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "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 core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.MsgTimeoutOnCloseResponse") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + 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::()? as i32); + } + } + } + Ok(MsgTimeoutOnCloseResponse { + result: result__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.MsgTimeoutOnCloseResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MsgTimeoutResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgTimeoutResponse", len)?; + if true { + let v = ResponseResultType::try_from(self.result) + .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.result)))?; + struct_ser.serialize_field("result", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgTimeoutResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "result", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Result, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "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 core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.MsgTimeoutResponse") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + 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::()? as i32); + } + } + } + Ok(MsgTimeoutResponse { + result: result__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.MsgTimeoutResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MsgUpdateParams { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgUpdateParams", len)?; + if true { + struct_ser.serialize_field("authority", &self.authority)?; + } + if let Some(v) = self.params.as_ref() { + struct_ser.serialize_field("params", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgUpdateParams { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "authority", + "params", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Authority, + Params, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "authority" => Ok(GeneratedField::Authority), + "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 = MsgUpdateParams; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.MsgUpdateParams") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut authority__ = None; + let mut params__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Authority => { + if authority__.is_some() { + return Err(serde::de::Error::duplicate_field("authority")); + } + authority__ = Some(map_.next_value()?); + } + GeneratedField::Params => { + if params__.is_some() { + return Err(serde::de::Error::duplicate_field("params")); + } + params__ = map_.next_value()?; + } + } + } + Ok(MsgUpdateParams { + authority: authority__.unwrap_or_default(), + params: params__, + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.MsgUpdateParams", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MsgUpdateParamsResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgUpdateParamsResponse", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MsgUpdateParamsResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgUpdateParamsResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.MsgUpdateParamsResponse") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(MsgUpdateParamsResponse { + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.MsgUpdateParamsResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Order { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + 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) + } +} +impl<'de> serde::Deserialize<'de> for Order { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + 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 core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> core::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> core::result::Result + where + E: serde::de::Error, + { + i32::try_from(v) + .ok() + .and_then(|x| x.try_into().ok()) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "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) + } +} +impl serde::Serialize for Packet { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.Packet", len)?; + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?; + } + if true { + struct_ser.serialize_field("sourcePort", &self.source_port)?; + } + if true { + struct_ser.serialize_field("sourceChannel", &self.source_channel)?; + } + if true { + struct_ser.serialize_field("destinationPort", &self.destination_port)?; + } + if true { + struct_ser.serialize_field("destinationChannel", &self.destination_channel)?; + } + if true { + #[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 true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("timeoutTimestamp", ::alloc::string::ToString::to_string(&self.timeout_timestamp).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Packet { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + 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, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "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 core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.Packet") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + 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) + } +} +impl serde::Serialize for PacketId { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.PacketId", len)?; + if true { + struct_ser.serialize_field("portId", &self.port_id)?; + } + if true { + struct_ser.serialize_field("channelId", &self.channel_id)?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PacketId { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + 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, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "portId" | "port_id" => Ok(GeneratedField::PortId), + "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), + "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 core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.PacketId") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut port_id__ = None; + let mut channel_id__ = None; + let mut 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) + } +} +impl serde::Serialize for PacketSequence { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.PacketSequence", len)?; + if true { + struct_ser.serialize_field("portId", &self.port_id)?; + } + if true { + struct_ser.serialize_field("channelId", &self.channel_id)?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PacketSequence { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + 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, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "portId" | "port_id" => Ok(GeneratedField::PortId), + "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), + "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 core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.PacketSequence") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut port_id__ = None; + let mut channel_id__ = None; + let mut 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) + } +} +impl serde::Serialize for PacketState { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.PacketState", len)?; + if true { + struct_ser.serialize_field("portId", &self.port_id)?; + } + if true { + struct_ser.serialize_field("channelId", &self.channel_id)?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PacketState { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + 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, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "portId" | "port_id" => Ok(GeneratedField::PortId), + "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), + "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 core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.PacketState") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut port_id__ = None; + let mut channel_id__ = None; + let mut 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) + } +} +impl serde::Serialize for Params { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.Params", len)?; + if let Some(v) = self.upgrade_timeout.as_ref() { + struct_ser.serialize_field("upgradeTimeout", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Params { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "upgrade_timeout", + "upgradeTimeout", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + UpgradeTimeout, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "upgradeTimeout" | "upgrade_timeout" => Ok(GeneratedField::UpgradeTimeout), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } - GeneratedField::TimeoutTimestamp => { - if timeout_timestamp__.is_some() { - return Err(serde::de::Error::duplicate_field("timeoutTimestamp")); + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Params; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.Params") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut upgrade_timeout__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::UpgradeTimeout => { + if upgrade_timeout__.is_some() { + return Err(serde::de::Error::duplicate_field("upgradeTimeout")); } - timeout_timestamp__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + upgrade_timeout__ = map_.next_value()?; + } + } + } + Ok(Params { + upgrade_timeout: upgrade_timeout__, + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.Params", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for QueryChannelClientStateRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryChannelClientStateRequest", len)?; + if true { + struct_ser.serialize_field("portId", &self.port_id)?; + } + if true { + struct_ser.serialize_field("channelId", &self.channel_id)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryChannelClientStateRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "port_id", + "portId", + "channel_id", + "channelId", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + PortId, + ChannelId, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "portId" | "port_id" => Ok(GeneratedField::PortId), + "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), + _ => 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 core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.QueryChannelClientStateRequest") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut port_id__ = None; + let mut channel_id__ = None; + 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) + } +} +impl serde::Serialize for QueryChannelClientStateResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryChannelClientStateResponse", len)?; + if let Some(v) = self.identified_client_state.as_ref() { + struct_ser.serialize_field("identifiedClientState", v)?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?; + } + if let Some(v) = self.proof_height.as_ref() { + struct_ser.serialize_field("proofHeight", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryChannelClientStateResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + 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, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "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 core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.QueryChannelClientStateResponse") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + 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(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(), + Ok(QueryChannelClientStateResponse { + identified_client_state: identified_client_state__, + proof: proof__.unwrap_or_default(), + proof_height: proof_height__, }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.Packet", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryChannelClientStateResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for PacketId { +impl serde::Serialize for QueryChannelConsensusStateRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -3646,7 +7077,10 @@ impl serde::Serialize for PacketId { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.PacketId", len)?; + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryChannelConsensusStateRequest", len)?; if true { struct_ser.serialize_field("portId", &self.port_id)?; } @@ -3655,12 +7089,16 @@ impl serde::Serialize for PacketId { } if true { #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?; + struct_ser.serialize_field("revisionNumber", ::alloc::string::ToString::to_string(&self.revision_number).as_str())?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("revisionHeight", ::alloc::string::ToString::to_string(&self.revision_height).as_str())?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for PacketId { +impl<'de> serde::Deserialize<'de> for QueryChannelConsensusStateRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where @@ -3671,14 +7109,18 @@ impl<'de> serde::Deserialize<'de> for PacketId { "portId", "channel_id", "channelId", - "sequence", + "revision_number", + "revisionNumber", + "revision_height", + "revisionHeight", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { PortId, ChannelId, - Sequence, + RevisionNumber, + RevisionHeight, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -3702,7 +7144,8 @@ impl<'de> serde::Deserialize<'de> for PacketId { match value { "portId" | "port_id" => Ok(GeneratedField::PortId), "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), - "sequence" => Ok(GeneratedField::Sequence), + "revisionNumber" | "revision_number" => Ok(GeneratedField::RevisionNumber), + "revisionHeight" | "revision_height" => Ok(GeneratedField::RevisionHeight), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -3712,19 +7155,20 @@ impl<'de> serde::Deserialize<'de> for PacketId { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PacketId; + type Value = QueryChannelConsensusStateRequest; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.PacketId") + formatter.write_str("struct ibc.core.channel.v1.QueryChannelConsensusStateRequest") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { let mut port_id__ = None; let mut channel_id__ = None; - let mut sequence__ = None; + let mut revision_number__ = None; + let mut revision_height__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::PortId => { @@ -3739,27 +7183,36 @@ impl<'de> serde::Deserialize<'de> for PacketId { } channel_id__ = Some(map_.next_value()?); } - GeneratedField::Sequence => { - if sequence__.is_some() { - return Err(serde::de::Error::duplicate_field("sequence")); + GeneratedField::RevisionNumber => { + if revision_number__.is_some() { + return Err(serde::de::Error::duplicate_field("revisionNumber")); } - sequence__ = + 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(PacketId { + Ok(QueryChannelConsensusStateRequest { port_id: port_id__.unwrap_or_default(), channel_id: channel_id__.unwrap_or_default(), - sequence: sequence__.unwrap_or_default(), + revision_number: revision_number__.unwrap_or_default(), + revision_height: revision_height__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.PacketId", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryChannelConsensusStateRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for PacketSequence { +impl serde::Serialize for QueryChannelConsensusStateResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -3776,39 +7229,48 @@ impl serde::Serialize for PacketSequence { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.PacketSequence", len)?; if true { - struct_ser.serialize_field("portId", &self.port_id)?; + 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 true { - struct_ser.serialize_field("channelId", &self.channel_id)?; + struct_ser.serialize_field("clientId", &self.client_id)?; } if true { #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?; + 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() } } -impl<'de> serde::Deserialize<'de> for PacketSequence { +impl<'de> serde::Deserialize<'de> for QueryChannelConsensusStateResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "port_id", - "portId", - "channel_id", - "channelId", - "sequence", + "consensus_state", + "consensusState", + "client_id", + "clientId", + "proof", + "proof_height", + "proofHeight", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - PortId, - ChannelId, - Sequence, + ConsensusState, + ClientId, + Proof, + ProofHeight, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -3830,9 +7292,10 @@ impl<'de> serde::Deserialize<'de> for PacketSequence { E: serde::de::Error, { match value { - "portId" | "port_id" => Ok(GeneratedField::PortId), - "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), - "sequence" => Ok(GeneratedField::Sequence), + "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)), } } @@ -3842,112 +7305,163 @@ impl<'de> serde::Deserialize<'de> for PacketSequence { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PacketSequence; + type Value = QueryChannelConsensusStateResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.PacketSequence") + formatter.write_str("struct ibc.core.channel.v1.QueryChannelConsensusStateResponse") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut port_id__ = None; - let mut channel_id__ = None; - let mut sequence__ = None; + 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::PortId => { - if port_id__.is_some() { - return Err(serde::de::Error::duplicate_field("portId")); + GeneratedField::ConsensusState => { + if consensus_state__.is_some() { + return Err(serde::de::Error::duplicate_field("consensusState")); } - port_id__ = Some(map_.next_value()?); + consensus_state__ = map_.next_value()?; } - GeneratedField::ChannelId => { - if channel_id__.is_some() { - return Err(serde::de::Error::duplicate_field("channelId")); + GeneratedField::ClientId => { + if client_id__.is_some() { + return Err(serde::de::Error::duplicate_field("clientId")); } - channel_id__ = Some(map_.next_value()?); + client_id__ = Some(map_.next_value()?); } - GeneratedField::Sequence => { - if sequence__.is_some() { - return Err(serde::de::Error::duplicate_field("sequence")); + GeneratedField::Proof => { + if proof__.is_some() { + return Err(serde::de::Error::duplicate_field("proof")); } - sequence__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + 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(PacketSequence { - port_id: port_id__.unwrap_or_default(), - channel_id: channel_id__.unwrap_or_default(), - sequence: sequence__.unwrap_or_default(), + 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.PacketSequence", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryChannelConsensusStateResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for PacketState { +impl serde::Serialize for QueryChannelParamsRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let mut len = 0; - if true { - len += 1; - } - if true { - len += 1; - } - if true { - len += 1; - } - if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.PacketState", len)?; - if true { - struct_ser.serialize_field("portId", &self.port_id)?; + let len = 0; + let struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryChannelParamsRequest", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryChannelParamsRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { } - if true { - struct_ser.serialize_field("channelId", &self.channel_id)?; + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } } - if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?; + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryChannelParamsRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.QueryChannelParamsRequest") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; + } + Ok(QueryChannelParamsRequest { + }) + } } + deserializer.deserialize_struct("ibc.core.channel.v1.QueryChannelParamsRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for QueryChannelParamsResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?; + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryChannelParamsResponse", len)?; + if let Some(v) = self.params.as_ref() { + struct_ser.serialize_field("params", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for PacketState { +impl<'de> serde::Deserialize<'de> for QueryChannelParamsResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "port_id", - "portId", - "channel_id", - "channelId", - "sequence", - "data", + "params", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - PortId, - ChannelId, - Sequence, - Data, + Params, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -3969,10 +7483,7 @@ impl<'de> serde::Deserialize<'de> for PacketState { 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), + "params" => Ok(GeneratedField::Params), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -3982,64 +7493,36 @@ impl<'de> serde::Deserialize<'de> for PacketState { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PacketState; + type Value = QueryChannelParamsResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.PacketState") + formatter.write_str("struct ibc.core.channel.v1.QueryChannelParamsResponse") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut port_id__ = None; - let mut channel_id__ = None; - let mut sequence__ = None; - let mut data__ = 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::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")); + GeneratedField::Params => { + if params__.is_some() { + return Err(serde::de::Error::duplicate_field("params")); } - data__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; + params__ = map_.next_value()?; } } } - 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(), + Ok(QueryChannelParamsResponse { + params: params__, }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.PacketState", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryChannelParamsResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryChannelClientStateRequest { +impl serde::Serialize for QueryChannelRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -4053,7 +7536,7 @@ impl serde::Serialize for QueryChannelClientStateRequest { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryChannelClientStateRequest", len)?; + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryChannelRequest", len)?; if true { struct_ser.serialize_field("portId", &self.port_id)?; } @@ -4063,7 +7546,7 @@ impl serde::Serialize for QueryChannelClientStateRequest { struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryChannelClientStateRequest { +impl<'de> serde::Deserialize<'de> for QueryChannelRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where @@ -4112,13 +7595,13 @@ impl<'de> serde::Deserialize<'de> for QueryChannelClientStateRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryChannelClientStateRequest; + type Value = QueryChannelRequest; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryChannelClientStateRequest") + formatter.write_str("struct ibc.core.channel.v1.QueryChannelRequest") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { @@ -4140,16 +7623,16 @@ impl<'de> serde::Deserialize<'de> for QueryChannelClientStateRequest { } } } - Ok(QueryChannelClientStateRequest { + Ok(QueryChannelRequest { port_id: port_id__.unwrap_or_default(), channel_id: channel_id__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.QueryChannelClientStateRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryChannelRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryChannelClientStateResponse { +impl serde::Serialize for QueryChannelResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -4166,9 +7649,9 @@ impl serde::Serialize for QueryChannelClientStateResponse { if true { 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)?; + 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 true { #[allow(clippy::needless_borrow)] @@ -4180,15 +7663,14 @@ impl serde::Serialize for QueryChannelClientStateResponse { struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryChannelClientStateResponse { +impl<'de> serde::Deserialize<'de> for QueryChannelResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "identified_client_state", - "identifiedClientState", + "channel", "proof", "proof_height", "proofHeight", @@ -4196,7 +7678,7 @@ impl<'de> serde::Deserialize<'de> for QueryChannelClientStateResponse { #[allow(clippy::enum_variant_names)] enum GeneratedField { - IdentifiedClientState, + Channel, Proof, ProofHeight, } @@ -4220,7 +7702,7 @@ impl<'de> serde::Deserialize<'de> for QueryChannelClientStateResponse { E: serde::de::Error, { match value { - "identifiedClientState" | "identified_client_state" => Ok(GeneratedField::IdentifiedClientState), + "channel" => Ok(GeneratedField::Channel), "proof" => Ok(GeneratedField::Proof), "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), @@ -4232,26 +7714,26 @@ impl<'de> serde::Deserialize<'de> for QueryChannelClientStateResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryChannelClientStateResponse; + type Value = QueryChannelResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryChannelClientStateResponse") + formatter.write_str("struct ibc.core.channel.v1.QueryChannelResponse") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut identified_client_state__ = None; + let mut channel__ = 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")); + GeneratedField::Channel => { + if channel__.is_some() { + return Err(serde::de::Error::duplicate_field("channel")); } - identified_client_state__ = map_.next_value()?; + channel__ = map_.next_value()?; } GeneratedField::Proof => { if proof__.is_some() { @@ -4269,17 +7751,17 @@ impl<'de> serde::Deserialize<'de> for QueryChannelClientStateResponse { } } } - Ok(QueryChannelClientStateResponse { - identified_client_state: identified_client_state__, + Ok(QueryChannelResponse { + channel: channel__, proof: proof__.unwrap_or_default(), proof_height: proof_height__, }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.QueryChannelClientStateResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryChannelResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryChannelConsensusStateRequest { +impl serde::Serialize for QueryChannelsRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -4290,56 +7772,26 @@ impl serde::Serialize for QueryChannelConsensusStateRequest { if true { len += 1; } - if true { - len += 1; - } - if true { - len += 1; - } - if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryChannelConsensusStateRequest", len)?; - if true { - struct_ser.serialize_field("portId", &self.port_id)?; - } - if true { - struct_ser.serialize_field("channelId", &self.channel_id)?; - } - if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("revisionNumber", ::alloc::string::ToString::to_string(&self.revision_number).as_str())?; - } - if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("revisionHeight", ::alloc::string::ToString::to_string(&self.revision_height).as_str())?; + 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() } } -impl<'de> serde::Deserialize<'de> for QueryChannelConsensusStateRequest { +impl<'de> serde::Deserialize<'de> for QueryChannelsRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "port_id", - "portId", - "channel_id", - "channelId", - "revision_number", - "revisionNumber", - "revision_height", - "revisionHeight", + "pagination", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - PortId, - ChannelId, - RevisionNumber, - RevisionHeight, + Pagination, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -4361,10 +7813,7 @@ impl<'de> serde::Deserialize<'de> for QueryChannelConsensusStateRequest { 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), + "pagination" => Ok(GeneratedField::Pagination), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -4374,64 +7823,36 @@ impl<'de> serde::Deserialize<'de> for QueryChannelConsensusStateRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryChannelConsensusStateRequest; + type Value = QueryChannelsRequest; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryChannelConsensusStateRequest") + formatter.write_str("struct ibc.core.channel.v1.QueryChannelsRequest") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut port_id__ = None; - let mut channel_id__ = None; - let mut revision_number__ = None; - let mut revision_height__ = 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::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")); + GeneratedField::Pagination => { + if pagination__.is_some() { + return Err(serde::de::Error::duplicate_field("pagination")); } - revision_height__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + pagination__ = map_.next_value()?; } } } - 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(), + Ok(QueryChannelsRequest { + pagination: pagination__, }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.QueryChannelConsensusStateRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryChannelsRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryChannelConsensusStateResponse { +impl serde::Serialize for QueryChannelsResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -4448,48 +7869,36 @@ impl serde::Serialize for QueryChannelConsensusStateResponse { if true { len += 1; } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryChannelsResponse", len)?; if true { - 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 true { - struct_ser.serialize_field("clientId", &self.client_id)?; + struct_ser.serialize_field("channels", &self.channels)?; } - if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?; + if let Some(v) = self.pagination.as_ref() { + struct_ser.serialize_field("pagination", v)?; } - if let Some(v) = self.proof_height.as_ref() { - struct_ser.serialize_field("proofHeight", v)?; + if let Some(v) = self.height.as_ref() { + struct_ser.serialize_field("height", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryChannelConsensusStateResponse { +impl<'de> serde::Deserialize<'de> for QueryChannelsResponse { #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "consensus_state", - "consensusState", - "client_id", - "clientId", - "proof", - "proof_height", - "proofHeight", + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "channels", + "pagination", + "height", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ConsensusState, - ClientId, - Proof, - ProofHeight, + Channels, + Pagination, + Height, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -4511,10 +7920,9 @@ impl<'de> serde::Deserialize<'de> for QueryChannelConsensusStateResponse { 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), + "channels" => Ok(GeneratedField::Channels), + "pagination" => Ok(GeneratedField::Pagination), + "height" => Ok(GeneratedField::Height), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -4524,62 +7932,52 @@ impl<'de> serde::Deserialize<'de> for QueryChannelConsensusStateResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryChannelConsensusStateResponse; + type Value = QueryChannelsResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryChannelConsensusStateResponse") + formatter.write_str("struct ibc.core.channel.v1.QueryChannelsResponse") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut consensus_state__ = None; - let mut client_id__ = None; - let mut proof__ = None; - let mut proof_height__ = None; + let mut channels__ = None; + let mut pagination__ = None; + let mut 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")); + GeneratedField::Channels => { + if channels__.is_some() { + return Err(serde::de::Error::duplicate_field("channels")); } - client_id__ = Some(map_.next_value()?); + channels__ = Some(map_.next_value()?); } - GeneratedField::Proof => { - if proof__.is_some() { - return Err(serde::de::Error::duplicate_field("proof")); + GeneratedField::Pagination => { + if pagination__.is_some() { + return Err(serde::de::Error::duplicate_field("pagination")); } - proof__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; + pagination__ = map_.next_value()?; } - GeneratedField::ProofHeight => { - if proof_height__.is_some() { - return Err(serde::de::Error::duplicate_field("proofHeight")); + GeneratedField::Height => { + if height__.is_some() { + return Err(serde::de::Error::duplicate_field("height")); } - proof_height__ = map_.next_value()?; + 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__, + Ok(QueryChannelsResponse { + channels: channels__.unwrap_or_default(), + pagination: pagination__, + height: height__, }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.QueryChannelConsensusStateResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryChannelsResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryChannelRequest { +impl serde::Serialize for QueryConnectionChannelsRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -4593,33 +7991,31 @@ impl serde::Serialize for QueryChannelRequest { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryChannelRequest", len)?; + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryConnectionChannelsRequest", len)?; if true { - struct_ser.serialize_field("portId", &self.port_id)?; + struct_ser.serialize_field("connection", &self.connection)?; } - if true { - 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() } } -impl<'de> serde::Deserialize<'de> for QueryChannelRequest { +impl<'de> serde::Deserialize<'de> for QueryConnectionChannelsRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "port_id", - "portId", - "channel_id", - "channelId", + "connection", + "pagination", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - PortId, - ChannelId, + Connection, + Pagination, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -4641,8 +8037,8 @@ impl<'de> serde::Deserialize<'de> for QueryChannelRequest { E: serde::de::Error, { match value { - "portId" | "port_id" => Ok(GeneratedField::PortId), - "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), + "connection" => Ok(GeneratedField::Connection), + "pagination" => Ok(GeneratedField::Pagination), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -4652,44 +8048,44 @@ impl<'de> serde::Deserialize<'de> for QueryChannelRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryChannelRequest; + type Value = QueryConnectionChannelsRequest; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryChannelRequest") + formatter.write_str("struct ibc.core.channel.v1.QueryConnectionChannelsRequest") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut port_id__ = None; - let mut channel_id__ = None; + let mut connection__ = 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")); + GeneratedField::Connection => { + if connection__.is_some() { + return Err(serde::de::Error::duplicate_field("connection")); } - port_id__ = Some(map_.next_value()?); + connection__ = Some(map_.next_value()?); } - GeneratedField::ChannelId => { - if channel_id__.is_some() { - return Err(serde::de::Error::duplicate_field("channelId")); + GeneratedField::Pagination => { + if pagination__.is_some() { + return Err(serde::de::Error::duplicate_field("pagination")); } - channel_id__ = Some(map_.next_value()?); + pagination__ = map_.next_value()?; } } } - Ok(QueryChannelRequest { - port_id: port_id__.unwrap_or_default(), - channel_id: channel_id__.unwrap_or_default(), + Ok(QueryConnectionChannelsRequest { + connection: connection__.unwrap_or_default(), + pagination: pagination__, }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.QueryChannelRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryConnectionChannelsRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryChannelResponse { +impl serde::Serialize for QueryConnectionChannelsResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -4706,38 +8102,36 @@ impl serde::Serialize for QueryChannelResponse { if true { 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)?; - } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryConnectionChannelsResponse", len)?; if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?; + struct_ser.serialize_field("channels", &self.channels)?; } - if let Some(v) = self.proof_height.as_ref() { - struct_ser.serialize_field("proofHeight", v)?; + 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() } } -impl<'de> serde::Deserialize<'de> for QueryChannelResponse { +impl<'de> serde::Deserialize<'de> for QueryConnectionChannelsResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "channel", - "proof", - "proof_height", - "proofHeight", + "channels", + "pagination", + "height", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Channel, - Proof, - ProofHeight, + Channels, + Pagination, + Height, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -4759,9 +8153,9 @@ impl<'de> serde::Deserialize<'de> for QueryChannelResponse { E: serde::de::Error, { match value { - "channel" => Ok(GeneratedField::Channel), - "proof" => Ok(GeneratedField::Proof), - "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight), + "channels" => Ok(GeneratedField::Channels), + "pagination" => Ok(GeneratedField::Pagination), + "height" => Ok(GeneratedField::Height), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -4771,54 +8165,52 @@ impl<'de> serde::Deserialize<'de> for QueryChannelResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryChannelResponse; + type Value = QueryConnectionChannelsResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryChannelResponse") + formatter.write_str("struct ibc.core.channel.v1.QueryConnectionChannelsResponse") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut channel__ = None; - let mut proof__ = None; - let mut proof_height__ = None; + let mut channels__ = None; + let mut pagination__ = None; + let mut 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")); + GeneratedField::Channels => { + if channels__.is_some() { + return Err(serde::de::Error::duplicate_field("channels")); } - channel__ = map_.next_value()?; + channels__ = Some(map_.next_value()?); } - GeneratedField::Proof => { - if proof__.is_some() { - return Err(serde::de::Error::duplicate_field("proof")); + GeneratedField::Pagination => { + if pagination__.is_some() { + return Err(serde::de::Error::duplicate_field("pagination")); } - proof__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; + pagination__ = map_.next_value()?; } - GeneratedField::ProofHeight => { - if proof_height__.is_some() { - return Err(serde::de::Error::duplicate_field("proofHeight")); + GeneratedField::Height => { + if height__.is_some() { + return Err(serde::de::Error::duplicate_field("height")); } - proof_height__ = map_.next_value()?; + height__ = map_.next_value()?; } } } - Ok(QueryChannelResponse { - channel: channel__, - proof: proof__.unwrap_or_default(), - proof_height: proof_height__, + Ok(QueryConnectionChannelsResponse { + channels: channels__.unwrap_or_default(), + pagination: pagination__, + height: height__, }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.QueryChannelResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryConnectionChannelsResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryChannelsRequest { +impl serde::Serialize for QueryNextSequenceReceiveRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -4829,26 +8221,36 @@ impl serde::Serialize for QueryChannelsRequest { if true { 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)?; + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryNextSequenceReceiveRequest", len)?; + if true { + struct_ser.serialize_field("portId", &self.port_id)?; + } + if true { + struct_ser.serialize_field("channelId", &self.channel_id)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryChannelsRequest { +impl<'de> serde::Deserialize<'de> for QueryNextSequenceReceiveRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "pagination", + "port_id", + "portId", + "channel_id", + "channelId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Pagination, + PortId, + ChannelId, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -4870,7 +8272,8 @@ impl<'de> serde::Deserialize<'de> for QueryChannelsRequest { E: serde::de::Error, { match value { - "pagination" => Ok(GeneratedField::Pagination), + "portId" | "port_id" => Ok(GeneratedField::PortId), + "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -4880,36 +8283,44 @@ impl<'de> serde::Deserialize<'de> for QueryChannelsRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryChannelsRequest; + type Value = QueryNextSequenceReceiveRequest; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryChannelsRequest") + formatter.write_str("struct ibc.core.channel.v1.QueryNextSequenceReceiveRequest") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut pagination__ = None; + let mut port_id__ = None; + let mut channel_id__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Pagination => { - if pagination__.is_some() { - return Err(serde::de::Error::duplicate_field("pagination")); + GeneratedField::PortId => { + if port_id__.is_some() { + return Err(serde::de::Error::duplicate_field("portId")); } - pagination__ = map_.next_value()?; + 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(QueryChannelsRequest { - pagination: pagination__, + Ok(QueryNextSequenceReceiveRequest { + port_id: port_id__.unwrap_or_default(), + channel_id: channel_id__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.QueryChannelsRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryNextSequenceReceiveRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryChannelsResponse { +impl serde::Serialize for QueryNextSequenceReceiveResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -4926,36 +8337,40 @@ impl serde::Serialize for QueryChannelsResponse { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryChannelsResponse", len)?; + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryNextSequenceReceiveResponse", len)?; if true { - struct_ser.serialize_field("channels", &self.channels)?; + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("nextSequenceReceive", ::alloc::string::ToString::to_string(&self.next_sequence_receive).as_str())?; } - if let Some(v) = self.pagination.as_ref() { - struct_ser.serialize_field("pagination", v)?; + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?; } - if let Some(v) = self.height.as_ref() { - struct_ser.serialize_field("height", v)?; + if let Some(v) = self.proof_height.as_ref() { + struct_ser.serialize_field("proofHeight", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryChannelsResponse { +impl<'de> serde::Deserialize<'de> for QueryNextSequenceReceiveResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "channels", - "pagination", - "height", + "next_sequence_receive", + "nextSequenceReceive", + "proof", + "proof_height", + "proofHeight", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Channels, - Pagination, - Height, + NextSequenceReceive, + Proof, + ProofHeight, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -4977,9 +8392,9 @@ impl<'de> serde::Deserialize<'de> for QueryChannelsResponse { E: serde::de::Error, { match value { - "channels" => Ok(GeneratedField::Channels), - "pagination" => Ok(GeneratedField::Pagination), - "height" => Ok(GeneratedField::Height), + "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)), } } @@ -4989,52 +8404,56 @@ impl<'de> serde::Deserialize<'de> for QueryChannelsResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryChannelsResponse; + type Value = QueryNextSequenceReceiveResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryChannelsResponse") + formatter.write_str("struct ibc.core.channel.v1.QueryNextSequenceReceiveResponse") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut channels__ = None; - let mut pagination__ = None; - let mut height__ = None; + 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::Channels => { - if channels__.is_some() { - return Err(serde::de::Error::duplicate_field("channels")); + GeneratedField::NextSequenceReceive => { + if next_sequence_receive__.is_some() { + return Err(serde::de::Error::duplicate_field("nextSequenceReceive")); } - channels__ = Some(map_.next_value()?); + next_sequence_receive__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::Pagination => { - if pagination__.is_some() { - return Err(serde::de::Error::duplicate_field("pagination")); + GeneratedField::Proof => { + if proof__.is_some() { + return Err(serde::de::Error::duplicate_field("proof")); } - pagination__ = map_.next_value()?; + proof__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; } - GeneratedField::Height => { - if height__.is_some() { - return Err(serde::de::Error::duplicate_field("height")); + GeneratedField::ProofHeight => { + if proof_height__.is_some() { + return Err(serde::de::Error::duplicate_field("proofHeight")); } - height__ = map_.next_value()?; + proof_height__ = map_.next_value()?; } } } - Ok(QueryChannelsResponse { - channels: channels__.unwrap_or_default(), - pagination: pagination__, - height: height__, + 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.QueryChannelsResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryNextSequenceReceiveResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryConnectionChannelsRequest { +impl serde::Serialize for QueryNextSequenceSendRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -5048,31 +8467,33 @@ impl serde::Serialize for QueryConnectionChannelsRequest { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryConnectionChannelsRequest", len)?; + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryNextSequenceSendRequest", len)?; if true { - struct_ser.serialize_field("connection", &self.connection)?; + struct_ser.serialize_field("portId", &self.port_id)?; } - if let Some(v) = self.pagination.as_ref() { - struct_ser.serialize_field("pagination", v)?; + if true { + struct_ser.serialize_field("channelId", &self.channel_id)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryConnectionChannelsRequest { +impl<'de> serde::Deserialize<'de> for QueryNextSequenceSendRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "connection", - "pagination", + "port_id", + "portId", + "channel_id", + "channelId", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Connection, - Pagination, + PortId, + ChannelId, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -5094,8 +8515,8 @@ impl<'de> serde::Deserialize<'de> for QueryConnectionChannelsRequest { E: serde::de::Error, { match value { - "connection" => Ok(GeneratedField::Connection), - "pagination" => Ok(GeneratedField::Pagination), + "portId" | "port_id" => Ok(GeneratedField::PortId), + "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -5105,44 +8526,44 @@ impl<'de> serde::Deserialize<'de> for QueryConnectionChannelsRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryConnectionChannelsRequest; + type Value = QueryNextSequenceSendRequest; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryConnectionChannelsRequest") + formatter.write_str("struct ibc.core.channel.v1.QueryNextSequenceSendRequest") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut connection__ = None; - let mut pagination__ = None; + let mut port_id__ = None; + let mut channel_id__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Connection => { - if connection__.is_some() { - return Err(serde::de::Error::duplicate_field("connection")); + GeneratedField::PortId => { + if port_id__.is_some() { + return Err(serde::de::Error::duplicate_field("portId")); } - connection__ = Some(map_.next_value()?); + port_id__ = Some(map_.next_value()?); } - GeneratedField::Pagination => { - if pagination__.is_some() { - return Err(serde::de::Error::duplicate_field("pagination")); + GeneratedField::ChannelId => { + if channel_id__.is_some() { + return Err(serde::de::Error::duplicate_field("channelId")); } - pagination__ = map_.next_value()?; + channel_id__ = Some(map_.next_value()?); } } } - Ok(QueryConnectionChannelsRequest { - connection: connection__.unwrap_or_default(), - pagination: pagination__, + Ok(QueryNextSequenceSendRequest { + port_id: port_id__.unwrap_or_default(), + channel_id: channel_id__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.QueryConnectionChannelsRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryNextSequenceSendRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryConnectionChannelsResponse { +impl serde::Serialize for QueryNextSequenceSendResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -5159,36 +8580,40 @@ impl serde::Serialize for QueryConnectionChannelsResponse { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryConnectionChannelsResponse", len)?; + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryNextSequenceSendResponse", len)?; if true { - struct_ser.serialize_field("channels", &self.channels)?; + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("nextSequenceSend", ::alloc::string::ToString::to_string(&self.next_sequence_send).as_str())?; } - if let Some(v) = self.pagination.as_ref() { - struct_ser.serialize_field("pagination", v)?; + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?; } - if let Some(v) = self.height.as_ref() { - struct_ser.serialize_field("height", v)?; + if let Some(v) = self.proof_height.as_ref() { + struct_ser.serialize_field("proofHeight", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryConnectionChannelsResponse { +impl<'de> serde::Deserialize<'de> for QueryNextSequenceSendResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "channels", - "pagination", - "height", + "next_sequence_send", + "nextSequenceSend", + "proof", + "proof_height", + "proofHeight", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Channels, - Pagination, - Height, + NextSequenceSend, + Proof, + ProofHeight, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -5210,9 +8635,9 @@ impl<'de> serde::Deserialize<'de> for QueryConnectionChannelsResponse { E: serde::de::Error, { match value { - "channels" => Ok(GeneratedField::Channels), - "pagination" => Ok(GeneratedField::Pagination), - "height" => Ok(GeneratedField::Height), + "nextSequenceSend" | "next_sequence_send" => Ok(GeneratedField::NextSequenceSend), + "proof" => Ok(GeneratedField::Proof), + "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -5222,52 +8647,56 @@ impl<'de> serde::Deserialize<'de> for QueryConnectionChannelsResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryConnectionChannelsResponse; + type Value = QueryNextSequenceSendResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryConnectionChannelsResponse") + formatter.write_str("struct ibc.core.channel.v1.QueryNextSequenceSendResponse") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut channels__ = None; - let mut pagination__ = None; - let mut height__ = None; + let mut next_sequence_send__ = None; + let mut proof__ = None; + let mut proof_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")); + GeneratedField::NextSequenceSend => { + if next_sequence_send__.is_some() { + return Err(serde::de::Error::duplicate_field("nextSequenceSend")); } - channels__ = Some(map_.next_value()?); + next_sequence_send__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::Pagination => { - if pagination__.is_some() { - return Err(serde::de::Error::duplicate_field("pagination")); + GeneratedField::Proof => { + if proof__.is_some() { + return Err(serde::de::Error::duplicate_field("proof")); } - pagination__ = map_.next_value()?; + proof__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; } - GeneratedField::Height => { - if height__.is_some() { - return Err(serde::de::Error::duplicate_field("height")); + GeneratedField::ProofHeight => { + if proof_height__.is_some() { + return Err(serde::de::Error::duplicate_field("proofHeight")); } - height__ = map_.next_value()?; + proof_height__ = map_.next_value()?; } } - } - Ok(QueryConnectionChannelsResponse { - channels: channels__.unwrap_or_default(), - pagination: pagination__, - height: height__, + } + Ok(QueryNextSequenceSendResponse { + next_sequence_send: next_sequence_send__.unwrap_or_default(), + proof: proof__.unwrap_or_default(), + proof_height: proof_height__, }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.QueryConnectionChannelsResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryNextSequenceSendResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryNextSequenceReceiveRequest { +impl serde::Serialize for QueryPacketAcknowledgementRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -5281,17 +8710,24 @@ impl serde::Serialize for QueryNextSequenceReceiveRequest { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryNextSequenceReceiveRequest", len)?; + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryPacketAcknowledgementRequest", len)?; if true { struct_ser.serialize_field("portId", &self.port_id)?; } if true { struct_ser.serialize_field("channelId", &self.channel_id)?; } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?; + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryNextSequenceReceiveRequest { +impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where @@ -5302,12 +8738,14 @@ impl<'de> serde::Deserialize<'de> for QueryNextSequenceReceiveRequest { "portId", "channel_id", "channelId", + "sequence", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { PortId, ChannelId, + Sequence, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -5331,6 +8769,7 @@ impl<'de> serde::Deserialize<'de> for QueryNextSequenceReceiveRequest { 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)), } } @@ -5340,18 +8779,19 @@ impl<'de> serde::Deserialize<'de> for QueryNextSequenceReceiveRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryNextSequenceReceiveRequest; + type Value = QueryPacketAcknowledgementRequest; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryNextSequenceReceiveRequest") + formatter.write_str("struct ibc.core.channel.v1.QueryPacketAcknowledgementRequest") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { let mut port_id__ = None; let mut channel_id__ = None; + let mut sequence__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::PortId => { @@ -5366,18 +8806,27 @@ impl<'de> serde::Deserialize<'de> for QueryNextSequenceReceiveRequest { } 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(QueryNextSequenceReceiveRequest { + 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.QueryNextSequenceReceiveRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryPacketAcknowledgementRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryNextSequenceReceiveResponse { +impl serde::Serialize for QueryPacketAcknowledgementResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -5394,10 +8843,10 @@ impl serde::Serialize for QueryNextSequenceReceiveResponse { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryNextSequenceReceiveResponse", len)?; + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryPacketAcknowledgementResponse", len)?; if true { #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("nextSequenceReceive", ::alloc::string::ToString::to_string(&self.next_sequence_receive).as_str())?; + struct_ser.serialize_field("acknowledgement", pbjson::private::base64::encode(&self.acknowledgement).as_str())?; } if true { #[allow(clippy::needless_borrow)] @@ -5409,15 +8858,14 @@ impl serde::Serialize for QueryNextSequenceReceiveResponse { struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryNextSequenceReceiveResponse { +impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "next_sequence_receive", - "nextSequenceReceive", + "acknowledgement", "proof", "proof_height", "proofHeight", @@ -5425,7 +8873,7 @@ impl<'de> serde::Deserialize<'de> for QueryNextSequenceReceiveResponse { #[allow(clippy::enum_variant_names)] enum GeneratedField { - NextSequenceReceive, + Acknowledgement, Proof, ProofHeight, } @@ -5449,7 +8897,7 @@ impl<'de> serde::Deserialize<'de> for QueryNextSequenceReceiveResponse { E: serde::de::Error, { match value { - "nextSequenceReceive" | "next_sequence_receive" => Ok(GeneratedField::NextSequenceReceive), + "acknowledgement" => Ok(GeneratedField::Acknowledgement), "proof" => Ok(GeneratedField::Proof), "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), @@ -5461,27 +8909,27 @@ impl<'de> serde::Deserialize<'de> for QueryNextSequenceReceiveResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryNextSequenceReceiveResponse; + type Value = QueryPacketAcknowledgementResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryNextSequenceReceiveResponse") + formatter.write_str("struct ibc.core.channel.v1.QueryPacketAcknowledgementResponse") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut next_sequence_receive__ = None; + let mut acknowledgement__ = 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")); + GeneratedField::Acknowledgement => { + if acknowledgement__.is_some() { + return Err(serde::de::Error::duplicate_field("acknowledgement")); } - next_sequence_receive__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + acknowledgement__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) ; } GeneratedField::Proof => { @@ -5500,17 +8948,17 @@ impl<'de> serde::Deserialize<'de> for QueryNextSequenceReceiveResponse { } } } - Ok(QueryNextSequenceReceiveResponse { - next_sequence_receive: next_sequence_receive__.unwrap_or_default(), + Ok(QueryPacketAcknowledgementResponse { + acknowledgement: acknowledgement__.unwrap_or_default(), proof: proof__.unwrap_or_default(), proof_height: proof_height__, }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.QueryNextSequenceReceiveResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryPacketAcknowledgementResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryNextSequenceSendRequest { +impl serde::Serialize for QueryPacketAcknowledgementsRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -5524,17 +8972,29 @@ impl serde::Serialize for QueryNextSequenceSendRequest { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryNextSequenceSendRequest", len)?; + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryPacketAcknowledgementsRequest", len)?; if true { struct_ser.serialize_field("portId", &self.port_id)?; } if true { struct_ser.serialize_field("channelId", &self.channel_id)?; } + if let Some(v) = self.pagination.as_ref() { + struct_ser.serialize_field("pagination", v)?; + } + if true { + struct_ser.serialize_field("packetCommitmentSequences", &self.packet_commitment_sequences.iter().map(::alloc::string::ToString::to_string).collect::<::alloc::vec::Vec<_>>())?; + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryNextSequenceSendRequest { +impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementsRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where @@ -5545,12 +9005,17 @@ impl<'de> serde::Deserialize<'de> for QueryNextSequenceSendRequest { "portId", "channel_id", "channelId", + "pagination", + "packet_commitment_sequences", + "packetCommitmentSequences", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { PortId, ChannelId, + Pagination, + PacketCommitmentSequences, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -5574,6 +9039,8 @@ impl<'de> serde::Deserialize<'de> for QueryNextSequenceSendRequest { 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)), } } @@ -5583,18 +9050,20 @@ impl<'de> serde::Deserialize<'de> for QueryNextSequenceSendRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryNextSequenceSendRequest; + type Value = QueryPacketAcknowledgementsRequest; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryNextSequenceSendRequest") + formatter.write_str("struct ibc.core.channel.v1.QueryPacketAcknowledgementsRequest") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { let mut port_id__ = None; let mut channel_id__ = None; + let mut pagination__ = None; + let mut packet_commitment_sequences__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::PortId => { @@ -5609,18 +9078,35 @@ impl<'de> serde::Deserialize<'de> for QueryNextSequenceSendRequest { } 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::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()? + .into_iter().map(|x| x.0).collect()) + ; + } } } - Ok(QueryNextSequenceSendRequest { + 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.QueryNextSequenceSendRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryPacketAcknowledgementsRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryNextSequenceSendResponse { +impl serde::Serialize for QueryPacketAcknowledgementsResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -5637,40 +9123,36 @@ impl serde::Serialize for QueryNextSequenceSendResponse { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryNextSequenceSendResponse", len)?; + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryPacketAcknowledgementsResponse", len)?; if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("nextSequenceSend", ::alloc::string::ToString::to_string(&self.next_sequence_send).as_str())?; + struct_ser.serialize_field("acknowledgements", &self.acknowledgements)?; } - if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?; + if let Some(v) = self.pagination.as_ref() { + struct_ser.serialize_field("pagination", v)?; } - if let Some(v) = self.proof_height.as_ref() { - struct_ser.serialize_field("proofHeight", v)?; + if let Some(v) = self.height.as_ref() { + struct_ser.serialize_field("height", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryNextSequenceSendResponse { +impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementsResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "next_sequence_send", - "nextSequenceSend", - "proof", - "proof_height", - "proofHeight", + "acknowledgements", + "pagination", + "height", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - NextSequenceSend, - Proof, - ProofHeight, + Acknowledgements, + Pagination, + Height, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -5692,9 +9174,9 @@ impl<'de> serde::Deserialize<'de> for QueryNextSequenceSendResponse { E: serde::de::Error, { match value { - "nextSequenceSend" | "next_sequence_send" => Ok(GeneratedField::NextSequenceSend), - "proof" => Ok(GeneratedField::Proof), - "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight), + "acknowledgements" => Ok(GeneratedField::Acknowledgements), + "pagination" => Ok(GeneratedField::Pagination), + "height" => Ok(GeneratedField::Height), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -5704,56 +9186,52 @@ impl<'de> serde::Deserialize<'de> for QueryNextSequenceSendResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryNextSequenceSendResponse; + type Value = QueryPacketAcknowledgementsResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryNextSequenceSendResponse") + formatter.write_str("struct ibc.core.channel.v1.QueryPacketAcknowledgementsResponse") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut next_sequence_send__ = None; - let mut proof__ = None; - let mut proof_height__ = None; + let mut acknowledgements__ = None; + let mut pagination__ = None; + let mut height__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::NextSequenceSend => { - if next_sequence_send__.is_some() { - return Err(serde::de::Error::duplicate_field("nextSequenceSend")); + GeneratedField::Acknowledgements => { + if acknowledgements__.is_some() { + return Err(serde::de::Error::duplicate_field("acknowledgements")); } - next_sequence_send__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + acknowledgements__ = Some(map_.next_value()?); } - GeneratedField::Proof => { - if proof__.is_some() { - return Err(serde::de::Error::duplicate_field("proof")); + GeneratedField::Pagination => { + if pagination__.is_some() { + return Err(serde::de::Error::duplicate_field("pagination")); } - proof__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; + pagination__ = map_.next_value()?; } - GeneratedField::ProofHeight => { - if proof_height__.is_some() { - return Err(serde::de::Error::duplicate_field("proofHeight")); + GeneratedField::Height => { + if height__.is_some() { + return Err(serde::de::Error::duplicate_field("height")); } - proof_height__ = map_.next_value()?; + height__ = map_.next_value()?; } } } - Ok(QueryNextSequenceSendResponse { - next_sequence_send: next_sequence_send__.unwrap_or_default(), - proof: proof__.unwrap_or_default(), - proof_height: proof_height__, + Ok(QueryPacketAcknowledgementsResponse { + acknowledgements: acknowledgements__.unwrap_or_default(), + pagination: pagination__, + height: height__, }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.QueryNextSequenceSendResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryPacketAcknowledgementsResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryPacketAcknowledgementRequest { +impl serde::Serialize for QueryPacketCommitmentRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -5770,7 +9248,7 @@ impl serde::Serialize for QueryPacketAcknowledgementRequest { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryPacketAcknowledgementRequest", len)?; + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryPacketCommitmentRequest", len)?; if true { struct_ser.serialize_field("portId", &self.port_id)?; } @@ -5784,7 +9262,7 @@ impl serde::Serialize for QueryPacketAcknowledgementRequest { struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementRequest { +impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where @@ -5836,13 +9314,13 @@ impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryPacketAcknowledgementRequest; + type Value = QueryPacketCommitmentRequest; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryPacketAcknowledgementRequest") + formatter.write_str("struct ibc.core.channel.v1.QueryPacketCommitmentRequest") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { @@ -5873,17 +9351,17 @@ impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementRequest { } } } - Ok(QueryPacketAcknowledgementRequest { + 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.QueryPacketAcknowledgementRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryPacketCommitmentRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryPacketAcknowledgementResponse { +impl serde::Serialize for QueryPacketCommitmentResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -5900,10 +9378,10 @@ impl serde::Serialize for QueryPacketAcknowledgementResponse { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryPacketAcknowledgementResponse", len)?; + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryPacketCommitmentResponse", len)?; if true { #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("acknowledgement", pbjson::private::base64::encode(&self.acknowledgement).as_str())?; + struct_ser.serialize_field("commitment", pbjson::private::base64::encode(&self.commitment).as_str())?; } if true { #[allow(clippy::needless_borrow)] @@ -5915,14 +9393,14 @@ impl serde::Serialize for QueryPacketAcknowledgementResponse { struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementResponse { +impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "acknowledgement", + "commitment", "proof", "proof_height", "proofHeight", @@ -5930,7 +9408,7 @@ impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementResponse { #[allow(clippy::enum_variant_names)] enum GeneratedField { - Acknowledgement, + Commitment, Proof, ProofHeight, } @@ -5954,7 +9432,7 @@ impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementResponse { E: serde::de::Error, { match value { - "acknowledgement" => Ok(GeneratedField::Acknowledgement), + "commitment" => Ok(GeneratedField::Commitment), "proof" => Ok(GeneratedField::Proof), "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), @@ -5966,26 +9444,26 @@ impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryPacketAcknowledgementResponse; + type Value = QueryPacketCommitmentResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryPacketAcknowledgementResponse") + formatter.write_str("struct ibc.core.channel.v1.QueryPacketCommitmentResponse") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut acknowledgement__ = None; + let mut commitment__ = 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")); + GeneratedField::Commitment => { + if commitment__.is_some() { + return Err(serde::de::Error::duplicate_field("commitment")); } - acknowledgement__ = + commitment__ = Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) ; } @@ -6005,17 +9483,17 @@ impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementResponse { } } } - Ok(QueryPacketAcknowledgementResponse { - acknowledgement: acknowledgement__.unwrap_or_default(), + Ok(QueryPacketCommitmentResponse { + commitment: commitment__.unwrap_or_default(), proof: proof__.unwrap_or_default(), proof_height: proof_height__, }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.QueryPacketAcknowledgementResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryPacketCommitmentResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryPacketAcknowledgementsRequest { +impl serde::Serialize for QueryPacketCommitmentsRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -6032,10 +9510,7 @@ impl serde::Serialize for QueryPacketAcknowledgementsRequest { if true { len += 1; } - if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryPacketAcknowledgementsRequest", len)?; + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryPacketCommitmentsRequest", len)?; if true { struct_ser.serialize_field("portId", &self.port_id)?; } @@ -6045,13 +9520,10 @@ impl serde::Serialize for QueryPacketAcknowledgementsRequest { if let Some(v) = self.pagination.as_ref() { struct_ser.serialize_field("pagination", v)?; } - if true { - struct_ser.serialize_field("packetCommitmentSequences", &self.packet_commitment_sequences.iter().map(::alloc::string::ToString::to_string).collect::<::alloc::vec::Vec<_>>())?; - } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementsRequest { +impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentsRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where @@ -6063,8 +9535,6 @@ impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementsRequest { "channel_id", "channelId", "pagination", - "packet_commitment_sequences", - "packetCommitmentSequences", ]; #[allow(clippy::enum_variant_names)] @@ -6072,7 +9542,6 @@ impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementsRequest { PortId, ChannelId, Pagination, - PacketCommitmentSequences, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -6097,7 +9566,6 @@ impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementsRequest { "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)), } } @@ -6107,20 +9575,19 @@ impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementsRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryPacketAcknowledgementsRequest; + type Value = QueryPacketCommitmentsRequest; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryPacketAcknowledgementsRequest") + formatter.write_str("struct ibc.core.channel.v1.QueryPacketCommitmentsRequest") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { let mut port_id__ = None; let mut channel_id__ = None; let mut pagination__ = None; - let mut packet_commitment_sequences__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::PortId => { @@ -6141,29 +9608,19 @@ impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementsRequest { } 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::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()? - .into_iter().map(|x| x.0).collect()) - ; - } } } - Ok(QueryPacketAcknowledgementsRequest { + Ok(QueryPacketCommitmentsRequest { 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) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryPacketCommitmentsRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryPacketAcknowledgementsResponse { +impl serde::Serialize for QueryPacketCommitmentsResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -6180,9 +9637,9 @@ impl serde::Serialize for QueryPacketAcknowledgementsResponse { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryPacketAcknowledgementsResponse", len)?; + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryPacketCommitmentsResponse", len)?; if true { - struct_ser.serialize_field("acknowledgements", &self.acknowledgements)?; + struct_ser.serialize_field("commitments", &self.commitments)?; } if let Some(v) = self.pagination.as_ref() { struct_ser.serialize_field("pagination", v)?; @@ -6193,21 +9650,21 @@ impl serde::Serialize for QueryPacketAcknowledgementsResponse { struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementsResponse { +impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentsResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "acknowledgements", + "commitments", "pagination", "height", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Acknowledgements, + Commitments, Pagination, Height, } @@ -6231,7 +9688,7 @@ impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementsResponse { E: serde::de::Error, { match value { - "acknowledgements" => Ok(GeneratedField::Acknowledgements), + "commitments" => Ok(GeneratedField::Commitments), "pagination" => Ok(GeneratedField::Pagination), "height" => Ok(GeneratedField::Height), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), @@ -6243,26 +9700,26 @@ impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementsResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryPacketAcknowledgementsResponse; + type Value = QueryPacketCommitmentsResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryPacketAcknowledgementsResponse") + formatter.write_str("struct ibc.core.channel.v1.QueryPacketCommitmentsResponse") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut acknowledgements__ = None; + let mut commitments__ = 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")); + GeneratedField::Commitments => { + if commitments__.is_some() { + return Err(serde::de::Error::duplicate_field("commitments")); } - acknowledgements__ = Some(map_.next_value()?); + commitments__ = Some(map_.next_value()?); } GeneratedField::Pagination => { if pagination__.is_some() { @@ -6278,17 +9735,17 @@ impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementsResponse { } } } - Ok(QueryPacketAcknowledgementsResponse { - acknowledgements: acknowledgements__.unwrap_or_default(), + Ok(QueryPacketCommitmentsResponse { + commitments: commitments__.unwrap_or_default(), pagination: pagination__, height: height__, }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.QueryPacketAcknowledgementsResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryPacketCommitmentsResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryPacketCommitmentRequest { +impl serde::Serialize for QueryPacketReceiptRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -6305,7 +9762,7 @@ impl serde::Serialize for QueryPacketCommitmentRequest { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryPacketCommitmentRequest", len)?; + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryPacketReceiptRequest", len)?; if true { struct_ser.serialize_field("portId", &self.port_id)?; } @@ -6319,7 +9776,7 @@ impl serde::Serialize for QueryPacketCommitmentRequest { struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentRequest { +impl<'de> serde::Deserialize<'de> for QueryPacketReceiptRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where @@ -6371,13 +9828,13 @@ impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryPacketCommitmentRequest; + type Value = QueryPacketReceiptRequest; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryPacketCommitmentRequest") + formatter.write_str("struct ibc.core.channel.v1.QueryPacketReceiptRequest") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { @@ -6408,17 +9865,17 @@ impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentRequest { } } } - Ok(QueryPacketCommitmentRequest { + 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.QueryPacketCommitmentRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryPacketReceiptRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryPacketCommitmentResponse { +impl serde::Serialize for QueryPacketReceiptResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -6435,10 +9892,9 @@ impl serde::Serialize for QueryPacketCommitmentResponse { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryPacketCommitmentResponse", len)?; + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryPacketReceiptResponse", len)?; if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("commitment", pbjson::private::base64::encode(&self.commitment).as_str())?; + struct_ser.serialize_field("received", &self.received)?; } if true { #[allow(clippy::needless_borrow)] @@ -6450,14 +9906,14 @@ impl serde::Serialize for QueryPacketCommitmentResponse { struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentResponse { +impl<'de> serde::Deserialize<'de> for QueryPacketReceiptResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "commitment", + "received", "proof", "proof_height", "proofHeight", @@ -6465,7 +9921,7 @@ impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentResponse { #[allow(clippy::enum_variant_names)] enum GeneratedField { - Commitment, + Received, Proof, ProofHeight, } @@ -6489,7 +9945,7 @@ impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentResponse { E: serde::de::Error, { match value { - "commitment" => Ok(GeneratedField::Commitment), + "received" => Ok(GeneratedField::Received), "proof" => Ok(GeneratedField::Proof), "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), @@ -6501,28 +9957,26 @@ impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryPacketCommitmentResponse; + type Value = QueryPacketReceiptResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryPacketCommitmentResponse") + formatter.write_str("struct ibc.core.channel.v1.QueryPacketReceiptResponse") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut commitment__ = None; + let mut received__ = 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")); + GeneratedField::Received => { + if received__.is_some() { + return Err(serde::de::Error::duplicate_field("received")); } - commitment__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; + received__ = Some(map_.next_value()?); } GeneratedField::Proof => { if proof__.is_some() { @@ -6540,17 +9994,17 @@ impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentResponse { } } } - Ok(QueryPacketCommitmentResponse { - commitment: commitment__.unwrap_or_default(), + Ok(QueryPacketReceiptResponse { + received: received__.unwrap_or_default(), proof: proof__.unwrap_or_default(), proof_height: proof_height__, }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.QueryPacketCommitmentResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryPacketReceiptResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryPacketCommitmentsRequest { +impl serde::Serialize for QueryUnreceivedAcksRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -6567,20 +10021,20 @@ impl serde::Serialize for QueryPacketCommitmentsRequest { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryPacketCommitmentsRequest", len)?; + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryUnreceivedAcksRequest", len)?; if true { struct_ser.serialize_field("portId", &self.port_id)?; } if true { struct_ser.serialize_field("channelId", &self.channel_id)?; } - if let Some(v) = self.pagination.as_ref() { - struct_ser.serialize_field("pagination", v)?; + if true { + struct_ser.serialize_field("packetAckSequences", &self.packet_ack_sequences.iter().map(::alloc::string::ToString::to_string).collect::<::alloc::vec::Vec<_>>())?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentsRequest { +impl<'de> serde::Deserialize<'de> for QueryUnreceivedAcksRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where @@ -6591,14 +10045,15 @@ impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentsRequest { "portId", "channel_id", "channelId", - "pagination", + "packet_ack_sequences", + "packetAckSequences", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { PortId, ChannelId, - Pagination, + PacketAckSequences, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -6622,7 +10077,7 @@ impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentsRequest { match value { "portId" | "port_id" => Ok(GeneratedField::PortId), "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), - "pagination" => Ok(GeneratedField::Pagination), + "packetAckSequences" | "packet_ack_sequences" => Ok(GeneratedField::PacketAckSequences), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -6632,19 +10087,19 @@ impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentsRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryPacketCommitmentsRequest; + type Value = QueryUnreceivedAcksRequest; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryPacketCommitmentsRequest") + formatter.write_str("struct ibc.core.channel.v1.QueryUnreceivedAcksRequest") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { let mut port_id__ = None; let mut channel_id__ = None; - let mut pagination__ = None; + let mut packet_ack_sequences__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::PortId => { @@ -6659,25 +10114,28 @@ impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentsRequest { } channel_id__ = Some(map_.next_value()?); } - GeneratedField::Pagination => { - if pagination__.is_some() { - return Err(serde::de::Error::duplicate_field("pagination")); + GeneratedField::PacketAckSequences => { + if packet_ack_sequences__.is_some() { + return Err(serde::de::Error::duplicate_field("packetAckSequences")); } - pagination__ = map_.next_value()?; + packet_ack_sequences__ = + Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()? + .into_iter().map(|x| x.0).collect()) + ; } } } - Ok(QueryPacketCommitmentsRequest { + Ok(QueryUnreceivedAcksRequest { port_id: port_id__.unwrap_or_default(), channel_id: channel_id__.unwrap_or_default(), - pagination: pagination__, + packet_ack_sequences: packet_ack_sequences__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.QueryPacketCommitmentsRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryUnreceivedAcksRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryPacketCommitmentsResponse { +impl serde::Serialize for QueryUnreceivedAcksResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -6691,15 +10149,9 @@ impl serde::Serialize for QueryPacketCommitmentsResponse { if true { len += 1; } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryUnreceivedAcksResponse", len)?; if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryPacketCommitmentsResponse", len)?; - if true { - struct_ser.serialize_field("commitments", &self.commitments)?; - } - if let Some(v) = self.pagination.as_ref() { - struct_ser.serialize_field("pagination", v)?; + struct_ser.serialize_field("sequences", &self.sequences.iter().map(::alloc::string::ToString::to_string).collect::<::alloc::vec::Vec<_>>())?; } if let Some(v) = self.height.as_ref() { struct_ser.serialize_field("height", v)?; @@ -6707,22 +10159,20 @@ impl serde::Serialize for QueryPacketCommitmentsResponse { struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentsResponse { +impl<'de> serde::Deserialize<'de> for QueryUnreceivedAcksResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "commitments", - "pagination", + "sequences", "height", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Commitments, - Pagination, + Sequences, Height, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -6745,8 +10195,7 @@ impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentsResponse { E: serde::de::Error, { match value { - "commitments" => Ok(GeneratedField::Commitments), - "pagination" => Ok(GeneratedField::Pagination), + "sequences" => Ok(GeneratedField::Sequences), "height" => Ok(GeneratedField::Height), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } @@ -6757,32 +10206,28 @@ impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentsResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryPacketCommitmentsResponse; + type Value = QueryUnreceivedAcksResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryPacketCommitmentsResponse") + formatter.write_str("struct ibc.core.channel.v1.QueryUnreceivedAcksResponse") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut commitments__ = None; - let mut pagination__ = None; + let mut sequences__ = 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")); + GeneratedField::Sequences => { + if sequences__.is_some() { + return Err(serde::de::Error::duplicate_field("sequences")); } - pagination__ = map_.next_value()?; + sequences__ = + Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()? + .into_iter().map(|x| x.0).collect()) + ; } GeneratedField::Height => { if height__.is_some() { @@ -6792,17 +10237,16 @@ impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentsResponse { } } } - Ok(QueryPacketCommitmentsResponse { - commitments: commitments__.unwrap_or_default(), - pagination: pagination__, + Ok(QueryUnreceivedAcksResponse { + sequences: sequences__.unwrap_or_default(), height: height__, }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.QueryPacketCommitmentsResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryUnreceivedAcksResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryPacketReceiptRequest { +impl serde::Serialize for QueryUnreceivedPacketsRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -6819,7 +10263,7 @@ impl serde::Serialize for QueryPacketReceiptRequest { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryPacketReceiptRequest", len)?; + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryUnreceivedPacketsRequest", len)?; if true { struct_ser.serialize_field("portId", &self.port_id)?; } @@ -6827,13 +10271,12 @@ impl serde::Serialize for QueryPacketReceiptRequest { struct_ser.serialize_field("channelId", &self.channel_id)?; } if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?; + struct_ser.serialize_field("packetCommitmentSequences", &self.packet_commitment_sequences.iter().map(::alloc::string::ToString::to_string).collect::<::alloc::vec::Vec<_>>())?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryPacketReceiptRequest { +impl<'de> serde::Deserialize<'de> for QueryUnreceivedPacketsRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where @@ -6844,14 +10287,15 @@ impl<'de> serde::Deserialize<'de> for QueryPacketReceiptRequest { "portId", "channel_id", "channelId", - "sequence", + "packet_commitment_sequences", + "packetCommitmentSequences", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { PortId, ChannelId, - Sequence, + PacketCommitmentSequences, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -6875,7 +10319,7 @@ impl<'de> serde::Deserialize<'de> for QueryPacketReceiptRequest { match value { "portId" | "port_id" => Ok(GeneratedField::PortId), "channelId" | "channel_id" => Ok(GeneratedField::ChannelId), - "sequence" => Ok(GeneratedField::Sequence), + "packetCommitmentSequences" | "packet_commitment_sequences" => Ok(GeneratedField::PacketCommitmentSequences), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -6885,19 +10329,19 @@ impl<'de> serde::Deserialize<'de> for QueryPacketReceiptRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryPacketReceiptRequest; + type Value = QueryUnreceivedPacketsRequest; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryPacketReceiptRequest") + formatter.write_str("struct ibc.core.channel.v1.QueryUnreceivedPacketsRequest") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { let mut port_id__ = None; let mut channel_id__ = None; - let mut sequence__ = None; + let mut packet_commitment_sequences__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::PortId => { @@ -6912,27 +10356,28 @@ impl<'de> serde::Deserialize<'de> for QueryPacketReceiptRequest { } channel_id__ = Some(map_.next_value()?); } - GeneratedField::Sequence => { - if sequence__.is_some() { - return Err(serde::de::Error::duplicate_field("sequence")); + GeneratedField::PacketCommitmentSequences => { + if packet_commitment_sequences__.is_some() { + return Err(serde::de::Error::duplicate_field("packetCommitmentSequences")); } - sequence__ = - Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + packet_commitment_sequences__ = + Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()? + .into_iter().map(|x| x.0).collect()) ; } } } - Ok(QueryPacketReceiptRequest { + Ok(QueryUnreceivedPacketsRequest { port_id: port_id__.unwrap_or_default(), channel_id: channel_id__.unwrap_or_default(), - sequence: sequence__.unwrap_or_default(), + packet_commitment_sequences: packet_commitment_sequences__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.QueryPacketReceiptRequest", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryUnreceivedPacketsRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryPacketReceiptResponse { +impl serde::Serialize for QueryUnreceivedPacketsResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -6946,41 +10391,31 @@ impl serde::Serialize for QueryPacketReceiptResponse { if true { len += 1; } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryUnreceivedPacketsResponse", len)?; if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryPacketReceiptResponse", len)?; - if true { - struct_ser.serialize_field("received", &self.received)?; - } - if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?; + struct_ser.serialize_field("sequences", &self.sequences.iter().map(::alloc::string::ToString::to_string).collect::<::alloc::vec::Vec<_>>())?; } - if let Some(v) = self.proof_height.as_ref() { - struct_ser.serialize_field("proofHeight", v)?; + if let Some(v) = self.height.as_ref() { + struct_ser.serialize_field("height", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryPacketReceiptResponse { +impl<'de> serde::Deserialize<'de> for QueryUnreceivedPacketsResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "received", - "proof", - "proof_height", - "proofHeight", + "sequences", + "height", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Received, - Proof, - ProofHeight, + Sequences, + Height, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -7002,9 +10437,8 @@ impl<'de> serde::Deserialize<'de> for QueryPacketReceiptResponse { E: serde::de::Error, { match value { - "received" => Ok(GeneratedField::Received), - "proof" => Ok(GeneratedField::Proof), - "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight), + "sequences" => Ok(GeneratedField::Sequences), + "height" => Ok(GeneratedField::Height), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -7014,54 +10448,47 @@ impl<'de> serde::Deserialize<'de> for QueryPacketReceiptResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryPacketReceiptResponse; + type Value = QueryUnreceivedPacketsResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryPacketReceiptResponse") + formatter.write_str("struct ibc.core.channel.v1.QueryUnreceivedPacketsResponse") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut received__ = None; - let mut proof__ = None; - let mut proof_height__ = None; + let mut sequences__ = None; + let mut 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")); + GeneratedField::Sequences => { + if sequences__.is_some() { + return Err(serde::de::Error::duplicate_field("sequences")); } - proof__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + sequences__ = + Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()? + .into_iter().map(|x| x.0).collect()) ; } - GeneratedField::ProofHeight => { - if proof_height__.is_some() { - return Err(serde::de::Error::duplicate_field("proofHeight")); + GeneratedField::Height => { + if height__.is_some() { + return Err(serde::de::Error::duplicate_field("height")); } - proof_height__ = map_.next_value()?; + height__ = map_.next_value()?; } } } - Ok(QueryPacketReceiptResponse { - received: received__.unwrap_or_default(), - proof: proof__.unwrap_or_default(), - proof_height: proof_height__, + Ok(QueryUnreceivedPacketsResponse { + sequences: sequences__.unwrap_or_default(), + height: height__, }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.QueryPacketReceiptResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryUnreceivedPacketsResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryUnreceivedAcksRequest { +impl serde::Serialize for QueryUpgradeErrorRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -7075,23 +10502,17 @@ impl serde::Serialize for QueryUnreceivedAcksRequest { if true { len += 1; } - if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryUnreceivedAcksRequest", len)?; + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryUpgradeErrorRequest", len)?; if true { struct_ser.serialize_field("portId", &self.port_id)?; } if true { struct_ser.serialize_field("channelId", &self.channel_id)?; } - if true { - struct_ser.serialize_field("packetAckSequences", &self.packet_ack_sequences.iter().map(::alloc::string::ToString::to_string).collect::<::alloc::vec::Vec<_>>())?; - } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryUnreceivedAcksRequest { +impl<'de> serde::Deserialize<'de> for QueryUpgradeErrorRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where @@ -7102,15 +10523,12 @@ impl<'de> serde::Deserialize<'de> for QueryUnreceivedAcksRequest { "portId", "channel_id", "channelId", - "packet_ack_sequences", - "packetAckSequences", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { PortId, ChannelId, - PacketAckSequences, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -7134,7 +10552,6 @@ impl<'de> serde::Deserialize<'de> for QueryUnreceivedAcksRequest { 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)), } } @@ -7144,19 +10561,18 @@ impl<'de> serde::Deserialize<'de> for QueryUnreceivedAcksRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryUnreceivedAcksRequest; + type Value = QueryUpgradeErrorRequest; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryUnreceivedAcksRequest") + formatter.write_str("struct ibc.core.channel.v1.QueryUpgradeErrorRequest") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { let mut port_id__ = None; let mut channel_id__ = None; - let mut packet_ack_sequences__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::PortId => { @@ -7171,28 +10587,18 @@ impl<'de> serde::Deserialize<'de> for QueryUnreceivedAcksRequest { } 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::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()? - .into_iter().map(|x| x.0).collect()) - ; - } } } - Ok(QueryUnreceivedAcksRequest { + Ok(QueryUpgradeErrorRequest { 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) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryUpgradeErrorRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryUnreceivedAcksResponse { +impl serde::Serialize for QueryUpgradeErrorResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -7206,31 +10612,42 @@ impl serde::Serialize for QueryUnreceivedAcksResponse { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryUnreceivedAcksResponse", len)?; if true { - struct_ser.serialize_field("sequences", &self.sequences.iter().map(::alloc::string::ToString::to_string).collect::<::alloc::vec::Vec<_>>())?; + len += 1; } - if let Some(v) = self.height.as_ref() { - struct_ser.serialize_field("height", v)?; + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryUpgradeErrorResponse", len)?; + if let Some(v) = self.error_receipt.as_ref() { + struct_ser.serialize_field("errorReceipt", v)?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?; + } + if let Some(v) = self.proof_height.as_ref() { + struct_ser.serialize_field("proofHeight", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryUnreceivedAcksResponse { +impl<'de> serde::Deserialize<'de> for QueryUpgradeErrorResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "sequences", - "height", + "error_receipt", + "errorReceipt", + "proof", + "proof_height", + "proofHeight", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Sequences, - Height, + ErrorReceipt, + Proof, + ProofHeight, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -7252,8 +10669,9 @@ impl<'de> serde::Deserialize<'de> for QueryUnreceivedAcksResponse { E: serde::de::Error, { match value { - "sequences" => Ok(GeneratedField::Sequences), - "height" => Ok(GeneratedField::Height), + "errorReceipt" | "error_receipt" => Ok(GeneratedField::ErrorReceipt), + "proof" => Ok(GeneratedField::Proof), + "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -7263,47 +10681,54 @@ impl<'de> serde::Deserialize<'de> for QueryUnreceivedAcksResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryUnreceivedAcksResponse; + type Value = QueryUpgradeErrorResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryUnreceivedAcksResponse") + formatter.write_str("struct ibc.core.channel.v1.QueryUpgradeErrorResponse") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut sequences__ = None; - let mut height__ = None; + let mut error_receipt__ = None; + let mut proof__ = None; + let mut proof_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")); + GeneratedField::ErrorReceipt => { + if error_receipt__.is_some() { + return Err(serde::de::Error::duplicate_field("errorReceipt")); } - sequences__ = - Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()? - .into_iter().map(|x| x.0).collect()) + error_receipt__ = 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::Height => { - if height__.is_some() { - return Err(serde::de::Error::duplicate_field("height")); + GeneratedField::ProofHeight => { + if proof_height__.is_some() { + return Err(serde::de::Error::duplicate_field("proofHeight")); } - height__ = map_.next_value()?; + proof_height__ = map_.next_value()?; } } } - Ok(QueryUnreceivedAcksResponse { - sequences: sequences__.unwrap_or_default(), - height: height__, + Ok(QueryUpgradeErrorResponse { + error_receipt: error_receipt__, + proof: proof__.unwrap_or_default(), + proof_height: proof_height__, }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.QueryUnreceivedAcksResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryUpgradeErrorResponse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryUnreceivedPacketsRequest { +impl serde::Serialize for QueryUpgradeRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -7317,23 +10742,17 @@ impl serde::Serialize for QueryUnreceivedPacketsRequest { if true { len += 1; } - if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryUnreceivedPacketsRequest", len)?; + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryUpgradeRequest", len)?; if true { struct_ser.serialize_field("portId", &self.port_id)?; } if true { struct_ser.serialize_field("channelId", &self.channel_id)?; } - if true { - struct_ser.serialize_field("packetCommitmentSequences", &self.packet_commitment_sequences.iter().map(::alloc::string::ToString::to_string).collect::<::alloc::vec::Vec<_>>())?; - } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryUnreceivedPacketsRequest { +impl<'de> serde::Deserialize<'de> for QueryUpgradeRequest { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where @@ -7344,15 +10763,12 @@ impl<'de> serde::Deserialize<'de> for QueryUnreceivedPacketsRequest { "portId", "channel_id", "channelId", - "packet_commitment_sequences", - "packetCommitmentSequences", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { PortId, ChannelId, - PacketCommitmentSequences, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -7376,7 +10792,6 @@ impl<'de> serde::Deserialize<'de> for QueryUnreceivedPacketsRequest { 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)), } } @@ -7386,19 +10801,18 @@ impl<'de> serde::Deserialize<'de> for QueryUnreceivedPacketsRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryUnreceivedPacketsRequest; + type Value = QueryUpgradeRequest; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryUnreceivedPacketsRequest") + formatter.write_str("struct ibc.core.channel.v1.QueryUpgradeRequest") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { let mut port_id__ = None; let mut channel_id__ = None; - let mut packet_commitment_sequences__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::PortId => { @@ -7413,28 +10827,18 @@ impl<'de> serde::Deserialize<'de> for QueryUnreceivedPacketsRequest { } 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::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()? - .into_iter().map(|x| x.0).collect()) - ; - } } } - Ok(QueryUnreceivedPacketsRequest { + Ok(QueryUpgradeRequest { 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) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryUpgradeRequest", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for QueryUnreceivedPacketsResponse { +impl serde::Serialize for QueryUpgradeResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -7448,31 +10852,41 @@ impl serde::Serialize for QueryUnreceivedPacketsResponse { if true { len += 1; } - let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryUnreceivedPacketsResponse", len)?; if true { - struct_ser.serialize_field("sequences", &self.sequences.iter().map(::alloc::string::ToString::to_string).collect::<::alloc::vec::Vec<_>>())?; + len += 1; } - if let Some(v) = self.height.as_ref() { - struct_ser.serialize_field("height", v)?; + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryUpgradeResponse", len)?; + if let Some(v) = self.upgrade.as_ref() { + struct_ser.serialize_field("upgrade", v)?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?; + } + if let Some(v) = self.proof_height.as_ref() { + struct_ser.serialize_field("proofHeight", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for QueryUnreceivedPacketsResponse { +impl<'de> serde::Deserialize<'de> for QueryUpgradeResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "sequences", - "height", + "upgrade", + "proof", + "proof_height", + "proofHeight", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Sequences, - Height, + Upgrade, + Proof, + ProofHeight, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -7493,9 +10907,10 @@ impl<'de> serde::Deserialize<'de> for QueryUnreceivedPacketsResponse { where E: serde::de::Error, { - match value { - "sequences" => Ok(GeneratedField::Sequences), - "height" => Ok(GeneratedField::Height), + match value { + "upgrade" => Ok(GeneratedField::Upgrade), + "proof" => Ok(GeneratedField::Proof), + "proofHeight" | "proof_height" => Ok(GeneratedField::ProofHeight), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -7505,44 +10920,51 @@ impl<'de> serde::Deserialize<'de> for QueryUnreceivedPacketsResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryUnreceivedPacketsResponse; + type Value = QueryUpgradeResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.core.channel.v1.QueryUnreceivedPacketsResponse") + formatter.write_str("struct ibc.core.channel.v1.QueryUpgradeResponse") } - fn visit_map(self, mut map_: V) -> core::result::Result + fn visit_map(self, mut map_: V) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut sequences__ = None; - let mut height__ = None; + let mut upgrade__ = None; + let mut proof__ = None; + let mut proof_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")); + GeneratedField::Upgrade => { + if upgrade__.is_some() { + return Err(serde::de::Error::duplicate_field("upgrade")); } - sequences__ = - Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()? - .into_iter().map(|x| x.0).collect()) + upgrade__ = 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::Height => { - if height__.is_some() { - return Err(serde::de::Error::duplicate_field("height")); + GeneratedField::ProofHeight => { + if proof_height__.is_some() { + return Err(serde::de::Error::duplicate_field("proofHeight")); } - height__ = map_.next_value()?; + proof_height__ = map_.next_value()?; } } } - Ok(QueryUnreceivedPacketsResponse { - sequences: sequences__.unwrap_or_default(), - height: height__, + Ok(QueryUpgradeResponse { + upgrade: upgrade__, + proof: proof__.unwrap_or_default(), + proof_height: proof_height__, }) } } - deserializer.deserialize_struct("ibc.core.channel.v1.QueryUnreceivedPacketsResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("ibc.core.channel.v1.QueryUpgradeResponse", FIELDS, GeneratedVisitor) } } impl serde::Serialize for ResponseResultType { @@ -7555,6 +10977,7 @@ impl serde::Serialize for ResponseResultType { Self::Unspecified => "RESPONSE_RESULT_TYPE_UNSPECIFIED", Self::Noop => "RESPONSE_RESULT_TYPE_NOOP", Self::Success => "RESPONSE_RESULT_TYPE_SUCCESS", + Self::Failure => "RESPONSE_RESULT_TYPE_FAILURE", }; serializer.serialize_str(variant) } @@ -7569,6 +10992,7 @@ impl<'de> serde::Deserialize<'de> for ResponseResultType { "RESPONSE_RESULT_TYPE_UNSPECIFIED", "RESPONSE_RESULT_TYPE_NOOP", "RESPONSE_RESULT_TYPE_SUCCESS", + "RESPONSE_RESULT_TYPE_FAILURE", ]; struct GeneratedVisitor; @@ -7612,6 +11036,7 @@ impl<'de> serde::Deserialize<'de> for ResponseResultType { "RESPONSE_RESULT_TYPE_UNSPECIFIED" => Ok(ResponseResultType::Unspecified), "RESPONSE_RESULT_TYPE_NOOP" => Ok(ResponseResultType::Noop), "RESPONSE_RESULT_TYPE_SUCCESS" => Ok(ResponseResultType::Success), + "RESPONSE_RESULT_TYPE_FAILURE" => Ok(ResponseResultType::Failure), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -7631,6 +11056,8 @@ impl serde::Serialize for State { Self::Tryopen => "STATE_TRYOPEN", Self::Open => "STATE_OPEN", Self::Closed => "STATE_CLOSED", + Self::Flushing => "STATE_FLUSHING", + Self::Flushcomplete => "STATE_FLUSHCOMPLETE", }; serializer.serialize_str(variant) } @@ -7647,6 +11074,8 @@ impl<'de> serde::Deserialize<'de> for State { "STATE_TRYOPEN", "STATE_OPEN", "STATE_CLOSED", + "STATE_FLUSHING", + "STATE_FLUSHCOMPLETE", ]; struct GeneratedVisitor; @@ -7692,6 +11121,8 @@ impl<'de> serde::Deserialize<'de> for State { "STATE_TRYOPEN" => Ok(State::Tryopen), "STATE_OPEN" => Ok(State::Open), "STATE_CLOSED" => Ok(State::Closed), + "STATE_FLUSHING" => Ok(State::Flushing), + "STATE_FLUSHCOMPLETE" => Ok(State::Flushcomplete), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -7810,3 +11241,260 @@ impl<'de> serde::Deserialize<'de> for Timeout { deserializer.deserialize_struct("ibc.core.channel.v1.Timeout", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for Upgrade { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.Upgrade", len)?; + if let Some(v) = self.fields.as_ref() { + struct_ser.serialize_field("fields", v)?; + } + if let Some(v) = self.timeout.as_ref() { + struct_ser.serialize_field("timeout", v)?; + } + if true { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("nextSequenceSend", ::alloc::string::ToString::to_string(&self.next_sequence_send).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Upgrade { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "fields", + "timeout", + "next_sequence_send", + "nextSequenceSend", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Fields, + Timeout, + NextSequenceSend, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "fields" => Ok(GeneratedField::Fields), + "timeout" => Ok(GeneratedField::Timeout), + "nextSequenceSend" | "next_sequence_send" => Ok(GeneratedField::NextSequenceSend), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Upgrade; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.Upgrade") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut fields__ = None; + let mut timeout__ = None; + let mut next_sequence_send__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Fields => { + if fields__.is_some() { + return Err(serde::de::Error::duplicate_field("fields")); + } + fields__ = map_.next_value()?; + } + GeneratedField::Timeout => { + if timeout__.is_some() { + return Err(serde::de::Error::duplicate_field("timeout")); + } + timeout__ = map_.next_value()?; + } + GeneratedField::NextSequenceSend => { + if next_sequence_send__.is_some() { + return Err(serde::de::Error::duplicate_field("nextSequenceSend")); + } + next_sequence_send__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(Upgrade { + fields: fields__, + timeout: timeout__, + next_sequence_send: next_sequence_send__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.Upgrade", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for UpgradeFields { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if true { + len += 1; + } + if true { + len += 1; + } + if true { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.UpgradeFields", len)?; + if true { + let v = Order::try_from(self.ordering) + .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.ordering)))?; + struct_ser.serialize_field("ordering", &v)?; + } + if true { + struct_ser.serialize_field("connectionHops", &self.connection_hops)?; + } + if true { + struct_ser.serialize_field("version", &self.version)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for UpgradeFields { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ordering", + "connection_hops", + "connectionHops", + "version", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Ordering, + ConnectionHops, + Version, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "ordering" => Ok(GeneratedField::Ordering), + "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 = UpgradeFields; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct ibc.core.channel.v1.UpgradeFields") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut ordering__ = None; + let mut connection_hops__ = None; + let mut version__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Ordering => { + if ordering__.is_some() { + return Err(serde::de::Error::duplicate_field("ordering")); + } + ordering__ = Some(map_.next_value::()? as i32); + } + 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(UpgradeFields { + ordering: ordering__.unwrap_or_default(), + connection_hops: connection_hops__.unwrap_or_default(), + version: version__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("ibc.core.channel.v1.UpgradeFields", FIELDS, GeneratedVisitor) + } +} diff --git a/src/prost/ibc.lightclients.wasm.v1.rs b/src/prost/ibc.lightclients.wasm.v1.rs deleted file mode 100644 index 0d4a293..0000000 --- a/src/prost/ibc.lightclients.wasm.v1.rs +++ /dev/null @@ -1,1100 +0,0 @@ -/// MsgStoreCode defines the request type for the StoreCode rpc. -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgStoreCode { - /// signer address - #[prost(string, tag = "1")] - pub signer: ::prost::alloc::string::String, - /// wasm byte code of light client contract. It can be raw or gzip compressed - #[prost(bytes = "vec", tag = "2")] - pub wasm_byte_code: ::prost::alloc::vec::Vec, -} -impl ::prost::Name for MsgStoreCode { - const NAME: &'static str = "MsgStoreCode"; - const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; - fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) - } -} -/// MsgStoreCodeResponse defines the response type for the StoreCode rpc -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgStoreCodeResponse { - /// checksum is the sha256 hash of the stored code - #[prost(bytes = "vec", tag = "1")] - pub checksum: ::prost::alloc::vec::Vec, -} -impl ::prost::Name for MsgStoreCodeResponse { - const NAME: &'static str = "MsgStoreCodeResponse"; - const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; - fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) - } -} -/// MsgRemoveChecksum defines the request type for the MsgRemoveChecksum rpc. -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgRemoveChecksum { - /// signer address - #[prost(string, tag = "1")] - pub signer: ::prost::alloc::string::String, - /// checksum is the sha256 hash to be removed from the store - #[prost(bytes = "vec", tag = "2")] - pub checksum: ::prost::alloc::vec::Vec, -} -impl ::prost::Name for MsgRemoveChecksum { - const NAME: &'static str = "MsgRemoveChecksum"; - const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; - fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) - } -} -/// MsgStoreChecksumResponse defines the response type for the StoreCode rpc -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgRemoveChecksumResponse {} -impl ::prost::Name for MsgRemoveChecksumResponse { - const NAME: &'static str = "MsgRemoveChecksumResponse"; - const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; - fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) - } -} -/// MsgMigrateContract defines the request type for the MigrateContract rpc. -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgMigrateContract { - /// signer address - #[prost(string, tag = "1")] - pub signer: ::prost::alloc::string::String, - /// the client id of the contract - #[prost(string, tag = "2")] - pub client_id: ::prost::alloc::string::String, - /// checksum is the sha256 hash of the new wasm byte code for the contract - #[prost(bytes = "vec", tag = "3")] - pub checksum: ::prost::alloc::vec::Vec, - /// the json encoded message to be passed to the contract on migration - #[prost(bytes = "vec", tag = "4")] - pub msg: ::prost::alloc::vec::Vec, -} -impl ::prost::Name for MsgMigrateContract { - const NAME: &'static str = "MsgMigrateContract"; - const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; - fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) - } -} -/// MsgMigrateContractResponse defines the response type for the MigrateContract rpc -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgMigrateContractResponse {} -impl ::prost::Name for MsgMigrateContractResponse { - const NAME: &'static str = "MsgMigrateContractResponse"; - const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; - fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) - } -} -/// Generated client implementations. -#[cfg(feature = "client")] -pub mod msg_client { - #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] - use tonic::codegen::*; - use tonic::codegen::http::Uri; - /// Msg defines the ibc/08-wasm Msg service. - #[derive(Debug, Clone)] - pub struct MsgClient { - inner: tonic::client::Grpc, - } - impl MsgClient { - /// Attempt to create a new client by connecting to a given endpoint. - pub async fn connect(dst: D) -> Result - where - D: TryInto, - D::Error: Into, - { - let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; - Ok(Self::new(conn)) - } - } - impl MsgClient - where - T: tonic::client::GrpcService, - T::Error: Into, - T::ResponseBody: Body + Send + 'static, - ::Error: Into + Send, - { - pub fn new(inner: T) -> Self { - let inner = tonic::client::Grpc::new(inner); - Self { inner } - } - pub fn with_origin(inner: T, origin: Uri) -> Self { - let inner = tonic::client::Grpc::with_origin(inner, origin); - Self { inner } - } - pub fn with_interceptor( - inner: T, - interceptor: F, - ) -> MsgClient> - where - F: tonic::service::Interceptor, - T::ResponseBody: Default, - T: tonic::codegen::Service< - http::Request, - Response = http::Response< - >::ResponseBody, - >, - >, - , - >>::Error: Into + 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 - } - /// StoreCode defines a rpc handler method for MsgStoreCode. - pub async fn store_code( - &mut self, - request: impl tonic::IntoRequest, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - > { - self.inner - .ready() - .await - .map_err(|e| { - tonic::Status::new( - tonic::Code::Unknown, - format!("Service was not ready: {}", e.into()), - ) - })?; - let codec = tonic::codec::ProstCodec::default(); - let path = http::uri::PathAndQuery::from_static( - "/ibc.lightclients.wasm.v1.Msg/StoreCode", - ); - let mut req = request.into_request(); - req.extensions_mut() - .insert(GrpcMethod::new("ibc.lightclients.wasm.v1.Msg", "StoreCode")); - self.inner.unary(req, path, codec).await - } - /// RemoveChecksum defines a rpc handler method for MsgRemoveChecksum. - pub async fn remove_checksum( - &mut self, - request: impl tonic::IntoRequest, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - > { - self.inner - .ready() - .await - .map_err(|e| { - tonic::Status::new( - tonic::Code::Unknown, - format!("Service was not ready: {}", e.into()), - ) - })?; - let codec = tonic::codec::ProstCodec::default(); - let path = http::uri::PathAndQuery::from_static( - "/ibc.lightclients.wasm.v1.Msg/RemoveChecksum", - ); - let mut req = request.into_request(); - req.extensions_mut() - .insert( - GrpcMethod::new("ibc.lightclients.wasm.v1.Msg", "RemoveChecksum"), - ); - self.inner.unary(req, path, codec).await - } - /// MigrateContract defines a rpc handler method for MsgMigrateContract. - pub async fn migrate_contract( - &mut self, - request: impl tonic::IntoRequest, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - > { - self.inner - .ready() - .await - .map_err(|e| { - tonic::Status::new( - tonic::Code::Unknown, - format!("Service was not ready: {}", e.into()), - ) - })?; - let codec = tonic::codec::ProstCodec::default(); - let path = http::uri::PathAndQuery::from_static( - "/ibc.lightclients.wasm.v1.Msg/MigrateContract", - ); - let mut req = request.into_request(); - req.extensions_mut() - .insert( - GrpcMethod::new("ibc.lightclients.wasm.v1.Msg", "MigrateContract"), - ); - self.inner.unary(req, path, codec).await - } - } -} -/// Generated server implementations. -#[cfg(feature = "server")] -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 { - /// StoreCode defines a rpc handler method for MsgStoreCode. - async fn store_code( - &self, - request: tonic::Request, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - >; - /// RemoveChecksum defines a rpc handler method for MsgRemoveChecksum. - async fn remove_checksum( - &self, - request: tonic::Request, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - >; - /// MigrateContract defines a rpc handler method for MsgMigrateContract. - async fn migrate_contract( - &self, - request: tonic::Request, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - >; - } - /// Msg defines the ibc/08-wasm Msg service. - #[derive(Debug)] - pub struct MsgServer { - inner: _Inner, - accept_compression_encodings: EnabledCompressionEncodings, - send_compression_encodings: EnabledCompressionEncodings, - max_decoding_message_size: Option, - max_encoding_message_size: Option, - } - struct _Inner(Arc); - impl MsgServer { - pub fn new(inner: T) -> Self { - Self::from_arc(Arc::new(inner)) - } - pub fn from_arc(inner: Arc) -> 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( - inner: T, - interceptor: F, - ) -> InterceptedService - where - F: tonic::service::Interceptor, - { - InterceptedService::new(Self::new(inner), interceptor) - } - /// Enable decompressing requests with the given encoding. - #[must_use] - pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { - self.accept_compression_encodings.enable(encoding); - self - } - /// Compress responses with the given encoding, if the client supports it. - #[must_use] - pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { - self.send_compression_encodings.enable(encoding); - self - } - /// Limits the maximum size of a decoded message. - /// - /// Default: `4MB` - #[must_use] - pub fn max_decoding_message_size(mut self, limit: usize) -> Self { - self.max_decoding_message_size = Some(limit); - self - } - /// Limits the maximum size of an encoded message. - /// - /// Default: `usize::MAX` - #[must_use] - pub fn max_encoding_message_size(mut self, limit: usize) -> Self { - self.max_encoding_message_size = Some(limit); - self - } - } - impl tonic::codegen::Service> for MsgServer - where - T: Msg, - B: Body + Send + 'static, - B::Error: Into + Send + 'static, - { - type Response = http::Response; - type Error = std::convert::Infallible; - type Future = BoxFuture; - fn poll_ready( - &mut self, - _cx: &mut Context<'_>, - ) -> Poll> { - Poll::Ready(Ok(())) - } - fn call(&mut self, req: http::Request) -> Self::Future { - let inner = self.inner.clone(); - match req.uri().path() { - "/ibc.lightclients.wasm.v1.Msg/StoreCode" => { - #[allow(non_camel_case_types)] - struct StoreCodeSvc(pub Arc); - impl tonic::server::UnaryService - for StoreCodeSvc { - type Response = super::MsgStoreCodeResponse; - type Future = BoxFuture< - tonic::Response, - tonic::Status, - >; - fn call( - &mut self, - request: tonic::Request, - ) -> Self::Future { - let inner = Arc::clone(&self.0); - let fut = async move { - ::store_code(&inner, request).await - }; - Box::pin(fut) - } - } - let accept_compression_encodings = self.accept_compression_encodings; - let send_compression_encodings = self.send_compression_encodings; - let max_decoding_message_size = self.max_decoding_message_size; - let max_encoding_message_size = self.max_encoding_message_size; - let inner = self.inner.clone(); - let fut = async move { - let inner = inner.0; - let method = StoreCodeSvc(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.lightclients.wasm.v1.Msg/RemoveChecksum" => { - #[allow(non_camel_case_types)] - struct RemoveChecksumSvc(pub Arc); - impl tonic::server::UnaryService - for RemoveChecksumSvc { - type Response = super::MsgRemoveChecksumResponse; - type Future = BoxFuture< - tonic::Response, - tonic::Status, - >; - fn call( - &mut self, - request: tonic::Request, - ) -> Self::Future { - let inner = Arc::clone(&self.0); - let fut = async move { - ::remove_checksum(&inner, request).await - }; - Box::pin(fut) - } - } - let accept_compression_encodings = self.accept_compression_encodings; - let send_compression_encodings = self.send_compression_encodings; - let max_decoding_message_size = self.max_decoding_message_size; - let max_encoding_message_size = self.max_encoding_message_size; - let inner = self.inner.clone(); - let fut = async move { - let inner = inner.0; - let method = RemoveChecksumSvc(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.lightclients.wasm.v1.Msg/MigrateContract" => { - #[allow(non_camel_case_types)] - struct MigrateContractSvc(pub Arc); - impl tonic::server::UnaryService - for MigrateContractSvc { - type Response = super::MsgMigrateContractResponse; - type Future = BoxFuture< - tonic::Response, - tonic::Status, - >; - fn call( - &mut self, - request: tonic::Request, - ) -> Self::Future { - let inner = Arc::clone(&self.0); - let fut = async move { - ::migrate_contract(&inner, request).await - }; - Box::pin(fut) - } - } - let accept_compression_encodings = self.accept_compression_encodings; - let send_compression_encodings = self.send_compression_encodings; - let max_decoding_message_size = self.max_decoding_message_size; - let max_encoding_message_size = self.max_encoding_message_size; - let inner = self.inner.clone(); - let fut = async move { - let inner = inner.0; - let method = MigrateContractSvc(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 Clone for MsgServer { - 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 Clone for _Inner { - fn clone(&self) -> Self { - Self(Arc::clone(&self.0)) - } - } - impl std::fmt::Debug for _Inner { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "{:?}", self.0) - } - } - impl tonic::server::NamedService for MsgServer { - const NAME: &'static str = "ibc.lightclients.wasm.v1.Msg"; - } -} -/// QueryChecksumsRequest is the request type for the Query/Checksums RPC method. -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryChecksumsRequest { - /// pagination defines an optional pagination for the request. - #[prost(message, optional, tag = "1")] - pub pagination: ::core::option::Option< - super::super::super::super::cosmos::base::query::v1beta1::PageRequest, - >, -} -impl ::prost::Name for QueryChecksumsRequest { - const NAME: &'static str = "QueryChecksumsRequest"; - const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; - fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) - } -} -/// QueryChecksumsResponse is the response type for the Query/Checksums RPC method. -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryChecksumsResponse { - /// checksums is a list of the hex encoded checksums of all wasm codes stored. - #[prost(string, repeated, tag = "1")] - pub checksums: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, - /// pagination defines the pagination in the response. - #[prost(message, optional, tag = "2")] - pub pagination: ::core::option::Option< - super::super::super::super::cosmos::base::query::v1beta1::PageResponse, - >, -} -impl ::prost::Name for QueryChecksumsResponse { - const NAME: &'static str = "QueryChecksumsResponse"; - const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; - fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) - } -} -/// QueryCodeRequest is the request type for the Query/Code RPC method. -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryCodeRequest { - /// checksum is a hex encoded string of the code stored. - #[prost(string, tag = "1")] - pub checksum: ::prost::alloc::string::String, -} -impl ::prost::Name for QueryCodeRequest { - const NAME: &'static str = "QueryCodeRequest"; - const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; - fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) - } -} -/// QueryCodeResponse is the response type for the Query/Code RPC method. -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryCodeResponse { - #[prost(bytes = "vec", tag = "1")] - pub data: ::prost::alloc::vec::Vec, -} -impl ::prost::Name for QueryCodeResponse { - const NAME: &'static str = "QueryCodeResponse"; - const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; - fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) - } -} -/// Generated client implementations. -#[cfg(feature = "client")] -pub mod query_client { - #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] - use tonic::codegen::*; - use tonic::codegen::http::Uri; - /// Query service for wasm module - #[derive(Debug, Clone)] - pub struct QueryClient { - inner: tonic::client::Grpc, - } - impl QueryClient { - /// Attempt to create a new client by connecting to a given endpoint. - pub async fn connect(dst: D) -> Result - where - D: TryInto, - D::Error: Into, - { - let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; - Ok(Self::new(conn)) - } - } - impl QueryClient - where - T: tonic::client::GrpcService, - T::Error: Into, - T::ResponseBody: Body + Send + 'static, - ::Error: Into + Send, - { - pub fn new(inner: T) -> Self { - let inner = tonic::client::Grpc::new(inner); - Self { inner } - } - pub fn with_origin(inner: T, origin: Uri) -> Self { - let inner = tonic::client::Grpc::with_origin(inner, origin); - Self { inner } - } - pub fn with_interceptor( - inner: T, - interceptor: F, - ) -> QueryClient> - where - F: tonic::service::Interceptor, - T::ResponseBody: Default, - T: tonic::codegen::Service< - http::Request, - Response = http::Response< - >::ResponseBody, - >, - >, - , - >>::Error: Into + 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 - } - /// Get all Wasm checksums - pub async fn checksums( - &mut self, - request: impl tonic::IntoRequest, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - > { - self.inner - .ready() - .await - .map_err(|e| { - tonic::Status::new( - tonic::Code::Unknown, - format!("Service was not ready: {}", e.into()), - ) - })?; - let codec = tonic::codec::ProstCodec::default(); - let path = http::uri::PathAndQuery::from_static( - "/ibc.lightclients.wasm.v1.Query/Checksums", - ); - let mut req = request.into_request(); - req.extensions_mut() - .insert(GrpcMethod::new("ibc.lightclients.wasm.v1.Query", "Checksums")); - self.inner.unary(req, path, codec).await - } - /// Get Wasm code for given code hash - pub async fn code( - &mut self, - request: impl tonic::IntoRequest, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - > { - self.inner - .ready() - .await - .map_err(|e| { - tonic::Status::new( - tonic::Code::Unknown, - format!("Service was not ready: {}", e.into()), - ) - })?; - let codec = tonic::codec::ProstCodec::default(); - let path = http::uri::PathAndQuery::from_static( - "/ibc.lightclients.wasm.v1.Query/Code", - ); - let mut req = request.into_request(); - req.extensions_mut() - .insert(GrpcMethod::new("ibc.lightclients.wasm.v1.Query", "Code")); - self.inner.unary(req, path, codec).await - } - } -} -/// Generated server implementations. -#[cfg(feature = "server")] -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 { - /// Get all Wasm checksums - async fn checksums( - &self, - request: tonic::Request, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - >; - /// Get Wasm code for given code hash - async fn code( - &self, - request: tonic::Request, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - >; - } - /// Query service for wasm module - #[derive(Debug)] - pub struct QueryServer { - inner: _Inner, - accept_compression_encodings: EnabledCompressionEncodings, - send_compression_encodings: EnabledCompressionEncodings, - max_decoding_message_size: Option, - max_encoding_message_size: Option, - } - struct _Inner(Arc); - impl QueryServer { - pub fn new(inner: T) -> Self { - Self::from_arc(Arc::new(inner)) - } - pub fn from_arc(inner: Arc) -> 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( - inner: T, - interceptor: F, - ) -> InterceptedService - where - F: tonic::service::Interceptor, - { - InterceptedService::new(Self::new(inner), interceptor) - } - /// Enable decompressing requests with the given encoding. - #[must_use] - pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { - self.accept_compression_encodings.enable(encoding); - self - } - /// Compress responses with the given encoding, if the client supports it. - #[must_use] - pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { - self.send_compression_encodings.enable(encoding); - self - } - /// Limits the maximum size of a decoded message. - /// - /// Default: `4MB` - #[must_use] - pub fn max_decoding_message_size(mut self, limit: usize) -> Self { - self.max_decoding_message_size = Some(limit); - self - } - /// Limits the maximum size of an encoded message. - /// - /// Default: `usize::MAX` - #[must_use] - pub fn max_encoding_message_size(mut self, limit: usize) -> Self { - self.max_encoding_message_size = Some(limit); - self - } - } - impl tonic::codegen::Service> for QueryServer - where - T: Query, - B: Body + Send + 'static, - B::Error: Into + Send + 'static, - { - type Response = http::Response; - type Error = std::convert::Infallible; - type Future = BoxFuture; - fn poll_ready( - &mut self, - _cx: &mut Context<'_>, - ) -> Poll> { - Poll::Ready(Ok(())) - } - fn call(&mut self, req: http::Request) -> Self::Future { - let inner = self.inner.clone(); - match req.uri().path() { - "/ibc.lightclients.wasm.v1.Query/Checksums" => { - #[allow(non_camel_case_types)] - struct ChecksumsSvc(pub Arc); - impl< - T: Query, - > tonic::server::UnaryService - for ChecksumsSvc { - type Response = super::QueryChecksumsResponse; - type Future = BoxFuture< - tonic::Response, - tonic::Status, - >; - fn call( - &mut self, - request: tonic::Request, - ) -> Self::Future { - let inner = Arc::clone(&self.0); - let fut = async move { - ::checksums(&inner, request).await - }; - Box::pin(fut) - } - } - let accept_compression_encodings = self.accept_compression_encodings; - let send_compression_encodings = self.send_compression_encodings; - let max_decoding_message_size = self.max_decoding_message_size; - let max_encoding_message_size = self.max_encoding_message_size; - let inner = self.inner.clone(); - let fut = async move { - let inner = inner.0; - let method = ChecksumsSvc(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.lightclients.wasm.v1.Query/Code" => { - #[allow(non_camel_case_types)] - struct CodeSvc(pub Arc); - impl tonic::server::UnaryService - for CodeSvc { - type Response = super::QueryCodeResponse; - type Future = BoxFuture< - tonic::Response, - tonic::Status, - >; - fn call( - &mut self, - request: tonic::Request, - ) -> Self::Future { - let inner = Arc::clone(&self.0); - let fut = async move { - ::code(&inner, request).await - }; - Box::pin(fut) - } - } - let accept_compression_encodings = self.accept_compression_encodings; - let send_compression_encodings = self.send_compression_encodings; - let max_decoding_message_size = self.max_decoding_message_size; - let max_encoding_message_size = self.max_encoding_message_size; - let inner = self.inner.clone(); - let fut = async move { - let inner = inner.0; - let method = CodeSvc(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 Clone for QueryServer { - 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 Clone for _Inner { - fn clone(&self) -> Self { - Self(Arc::clone(&self.0)) - } - } - impl std::fmt::Debug for _Inner { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "{:?}", self.0) - } - } - impl tonic::server::NamedService for QueryServer { - const NAME: &'static str = "ibc.lightclients.wasm.v1.Query"; - } -} -/// GenesisState defines 08-wasm's keeper genesis state -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct GenesisState { - /// uploaded light client wasm contracts - #[prost(message, repeated, tag = "1")] - pub contracts: ::prost::alloc::vec::Vec, -} -impl ::prost::Name for GenesisState { - const NAME: &'static str = "GenesisState"; - const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; - fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) - } -} -/// Contract stores contract code -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct Contract { - /// contract byte code - #[prost(bytes = "vec", tag = "1")] - pub code_bytes: ::prost::alloc::vec::Vec, -} -impl ::prost::Name for Contract { - const NAME: &'static str = "Contract"; - const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; - fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) - } -} -/// Wasm light client's Client state -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ClientState { - /// bytes encoding the client state of the underlying light client - /// implemented as a Wasm contract. - #[prost(bytes = "vec", tag = "1")] - pub data: ::prost::alloc::vec::Vec, - #[prost(bytes = "vec", tag = "2")] - pub checksum: ::prost::alloc::vec::Vec, - #[prost(message, optional, tag = "3")] - pub latest_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.wasm.v1"; - fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) - } -} -/// Wasm light client's ConsensusState -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ConsensusState { - /// bytes encoding the consensus state of the underlying light client - /// implemented as a Wasm contract. - #[prost(bytes = "vec", tag = "1")] - pub data: ::prost::alloc::vec::Vec, -} -impl ::prost::Name for ConsensusState { - const NAME: &'static str = "ConsensusState"; - const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; - fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) - } -} -/// Wasm light client message (either header(s) or misbehaviour) -#[cfg_attr( - all(feature = "json-schema", feature = "serde"), - derive(::schemars::JsonSchema) -)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ClientMessage { - #[prost(bytes = "vec", tag = "1")] - pub data: ::prost::alloc::vec::Vec, -} -impl ::prost::Name for ClientMessage { - const NAME: &'static str = "ClientMessage"; - const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; - fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) - } -} -/// Checksums defines a list of all checksums that are stored -/// -/// Deprecated: This message is deprecated in favor of storing the checksums -/// using a Collections.KeySet. -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct Checksums { - #[prost(bytes = "vec", repeated, tag = "1")] - pub checksums: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, -} -impl ::prost::Name for Checksums { - const NAME: &'static str = "Checksums"; - const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; - fn full_name() -> ::prost::alloc::string::String { - ::prost::alloc::format!("ibc.lightclients.wasm.v1.{}", Self::NAME) - } -} diff --git a/src/prost/ibc.lightclients.wasm.v1.serde.rs b/src/prost/ibc.lightclients.wasm.v1.serde.rs deleted file mode 100644 index 1cb03d5..0000000 --- a/src/prost/ibc.lightclients.wasm.v1.serde.rs +++ /dev/null @@ -1,1592 +0,0 @@ -impl serde::Serialize for Checksums { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> core::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.Checksums", len)?; - if true { - struct_ser.serialize_field("checksums", &self.checksums.iter().map(pbjson::private::base64::encode).collect::<::alloc::vec::Vec<_>>())?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for Checksums { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "checksums", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Checksums, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> core::result::Result - where - E: serde::de::Error, - { - match value { - "checksums" => Ok(GeneratedField::Checksums), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Checksums; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.lightclients.wasm.v1.Checksums") - } - - fn visit_map(self, mut map_: V) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut checksums__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Checksums => { - if checksums__.is_some() { - return Err(serde::de::Error::duplicate_field("checksums")); - } - checksums__ = - Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::BytesDeserialize<_>>>()? - .into_iter().map(|x| x.0).collect()) - ; - } - } - } - Ok(Checksums { - checksums: checksums__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("ibc.lightclients.wasm.v1.Checksums", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ClientMessage { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> core::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.ClientMessage", len)?; - if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ClientMessage { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "data", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Data, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> core::result::Result - where - E: serde::de::Error, - { - match value { - "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 = ClientMessage; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.lightclients.wasm.v1.ClientMessage") - } - - fn visit_map(self, mut map_: V) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut data__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Data => { - if data__.is_some() { - return Err(serde::de::Error::duplicate_field("data")); - } - data__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; - } - } - } - Ok(ClientMessage { - data: data__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("ibc.lightclients.wasm.v1.ClientMessage", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ClientState { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> core::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if true { - len += 1; - } - if true { - len += 1; - } - if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.ClientState", len)?; - if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?; - } - if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("checksum", pbjson::private::base64::encode(&self.checksum).as_str())?; - } - if let Some(v) = self.latest_height.as_ref() { - struct_ser.serialize_field("latestHeight", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ClientState { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "data", - "checksum", - "latest_height", - "latestHeight", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Data, - Checksum, - LatestHeight, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> core::result::Result - where - E: serde::de::Error, - { - match value { - "data" => Ok(GeneratedField::Data), - "checksum" => Ok(GeneratedField::Checksum), - "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 = ClientState; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.lightclients.wasm.v1.ClientState") - } - - fn visit_map(self, mut map_: V) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut data__ = None; - let mut checksum__ = None; - let mut latest_height__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Data => { - if data__.is_some() { - return Err(serde::de::Error::duplicate_field("data")); - } - data__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; - } - GeneratedField::Checksum => { - if checksum__.is_some() { - return Err(serde::de::Error::duplicate_field("checksum")); - } - checksum__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; - } - GeneratedField::LatestHeight => { - if latest_height__.is_some() { - return Err(serde::de::Error::duplicate_field("latestHeight")); - } - latest_height__ = map_.next_value()?; - } - } - } - Ok(ClientState { - data: data__.unwrap_or_default(), - checksum: checksum__.unwrap_or_default(), - latest_height: latest_height__, - }) - } - } - deserializer.deserialize_struct("ibc.lightclients.wasm.v1.ClientState", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ConsensusState { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> core::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.ConsensusState", len)?; - if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ConsensusState { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "data", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Data, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> core::result::Result - where - E: serde::de::Error, - { - match value { - "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 = ConsensusState; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.lightclients.wasm.v1.ConsensusState") - } - - fn visit_map(self, mut map_: V) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut data__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Data => { - if data__.is_some() { - return Err(serde::de::Error::duplicate_field("data")); - } - data__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; - } - } - } - Ok(ConsensusState { - data: data__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("ibc.lightclients.wasm.v1.ConsensusState", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for Contract { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> core::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.Contract", len)?; - if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("codeBytes", pbjson::private::base64::encode(&self.code_bytes).as_str())?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for Contract { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "code_bytes", - "codeBytes", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - CodeBytes, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> core::result::Result - where - E: serde::de::Error, - { - match value { - "codeBytes" | "code_bytes" => Ok(GeneratedField::CodeBytes), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Contract; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.lightclients.wasm.v1.Contract") - } - - fn visit_map(self, mut map_: V) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut code_bytes__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::CodeBytes => { - if code_bytes__.is_some() { - return Err(serde::de::Error::duplicate_field("codeBytes")); - } - code_bytes__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; - } - } - } - Ok(Contract { - code_bytes: code_bytes__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("ibc.lightclients.wasm.v1.Contract", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for GenesisState { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> core::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.GenesisState", len)?; - if true { - struct_ser.serialize_field("contracts", &self.contracts)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for GenesisState { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "contracts", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Contracts, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> core::result::Result - where - E: serde::de::Error, - { - match value { - "contracts" => Ok(GeneratedField::Contracts), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GenesisState; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.lightclients.wasm.v1.GenesisState") - } - - fn visit_map(self, mut map_: V) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut contracts__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Contracts => { - if contracts__.is_some() { - return Err(serde::de::Error::duplicate_field("contracts")); - } - contracts__ = Some(map_.next_value()?); - } - } - } - Ok(GenesisState { - contracts: contracts__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("ibc.lightclients.wasm.v1.GenesisState", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for MsgMigrateContract { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> core::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if true { - len += 1; - } - if true { - len += 1; - } - if true { - len += 1; - } - if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.MsgMigrateContract", len)?; - if true { - struct_ser.serialize_field("signer", &self.signer)?; - } - if true { - struct_ser.serialize_field("clientId", &self.client_id)?; - } - if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("checksum", pbjson::private::base64::encode(&self.checksum).as_str())?; - } - if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("msg", pbjson::private::base64::encode(&self.msg).as_str())?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for MsgMigrateContract { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "signer", - "client_id", - "clientId", - "checksum", - "msg", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Signer, - ClientId, - Checksum, - Msg, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> core::result::Result - where - E: serde::de::Error, - { - match value { - "signer" => Ok(GeneratedField::Signer), - "clientId" | "client_id" => Ok(GeneratedField::ClientId), - "checksum" => Ok(GeneratedField::Checksum), - "msg" => Ok(GeneratedField::Msg), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MsgMigrateContract; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.lightclients.wasm.v1.MsgMigrateContract") - } - - fn visit_map(self, mut map_: V) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut signer__ = None; - let mut client_id__ = None; - let mut checksum__ = None; - let mut msg__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Signer => { - if signer__.is_some() { - return Err(serde::de::Error::duplicate_field("signer")); - } - signer__ = Some(map_.next_value()?); - } - GeneratedField::ClientId => { - if client_id__.is_some() { - return Err(serde::de::Error::duplicate_field("clientId")); - } - client_id__ = Some(map_.next_value()?); - } - GeneratedField::Checksum => { - if checksum__.is_some() { - return Err(serde::de::Error::duplicate_field("checksum")); - } - checksum__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; - } - GeneratedField::Msg => { - if msg__.is_some() { - return Err(serde::de::Error::duplicate_field("msg")); - } - msg__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; - } - } - } - Ok(MsgMigrateContract { - signer: signer__.unwrap_or_default(), - client_id: client_id__.unwrap_or_default(), - checksum: checksum__.unwrap_or_default(), - msg: msg__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("ibc.lightclients.wasm.v1.MsgMigrateContract", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for MsgMigrateContractResponse { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> core::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.MsgMigrateContractResponse", len)?; - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for MsgMigrateContractResponse { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> core::result::Result - where - E: serde::de::Error, - { - Err(serde::de::Error::unknown_field(value, FIELDS)) - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MsgMigrateContractResponse; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.lightclients.wasm.v1.MsgMigrateContractResponse") - } - - fn visit_map(self, mut map_: V) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; - } - Ok(MsgMigrateContractResponse { - }) - } - } - deserializer.deserialize_struct("ibc.lightclients.wasm.v1.MsgMigrateContractResponse", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for MsgRemoveChecksum { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> core::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if true { - len += 1; - } - if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.MsgRemoveChecksum", len)?; - if true { - struct_ser.serialize_field("signer", &self.signer)?; - } - if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("checksum", pbjson::private::base64::encode(&self.checksum).as_str())?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for MsgRemoveChecksum { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "signer", - "checksum", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Signer, - Checksum, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> core::result::Result - where - E: serde::de::Error, - { - match value { - "signer" => Ok(GeneratedField::Signer), - "checksum" => Ok(GeneratedField::Checksum), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MsgRemoveChecksum; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.lightclients.wasm.v1.MsgRemoveChecksum") - } - - fn visit_map(self, mut map_: V) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut signer__ = None; - let mut checksum__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Signer => { - if signer__.is_some() { - return Err(serde::de::Error::duplicate_field("signer")); - } - signer__ = Some(map_.next_value()?); - } - GeneratedField::Checksum => { - if checksum__.is_some() { - return Err(serde::de::Error::duplicate_field("checksum")); - } - checksum__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; - } - } - } - Ok(MsgRemoveChecksum { - signer: signer__.unwrap_or_default(), - checksum: checksum__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("ibc.lightclients.wasm.v1.MsgRemoveChecksum", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for MsgRemoveChecksumResponse { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> core::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.MsgRemoveChecksumResponse", len)?; - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for MsgRemoveChecksumResponse { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> core::result::Result - where - E: serde::de::Error, - { - Err(serde::de::Error::unknown_field(value, FIELDS)) - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MsgRemoveChecksumResponse; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.lightclients.wasm.v1.MsgRemoveChecksumResponse") - } - - fn visit_map(self, mut map_: V) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; - } - Ok(MsgRemoveChecksumResponse { - }) - } - } - deserializer.deserialize_struct("ibc.lightclients.wasm.v1.MsgRemoveChecksumResponse", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for MsgStoreCode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> core::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if true { - len += 1; - } - if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.MsgStoreCode", len)?; - if true { - struct_ser.serialize_field("signer", &self.signer)?; - } - if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("wasmByteCode", pbjson::private::base64::encode(&self.wasm_byte_code).as_str())?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for MsgStoreCode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "signer", - "wasm_byte_code", - "wasmByteCode", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Signer, - WasmByteCode, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> core::result::Result - where - E: serde::de::Error, - { - match value { - "signer" => Ok(GeneratedField::Signer), - "wasmByteCode" | "wasm_byte_code" => Ok(GeneratedField::WasmByteCode), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MsgStoreCode; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.lightclients.wasm.v1.MsgStoreCode") - } - - fn visit_map(self, mut map_: V) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut signer__ = None; - let mut wasm_byte_code__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Signer => { - if signer__.is_some() { - return Err(serde::de::Error::duplicate_field("signer")); - } - signer__ = Some(map_.next_value()?); - } - GeneratedField::WasmByteCode => { - if wasm_byte_code__.is_some() { - return Err(serde::de::Error::duplicate_field("wasmByteCode")); - } - wasm_byte_code__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; - } - } - } - Ok(MsgStoreCode { - signer: signer__.unwrap_or_default(), - wasm_byte_code: wasm_byte_code__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("ibc.lightclients.wasm.v1.MsgStoreCode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for MsgStoreCodeResponse { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> core::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.MsgStoreCodeResponse", len)?; - if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("checksum", pbjson::private::base64::encode(&self.checksum).as_str())?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for MsgStoreCodeResponse { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "checksum", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Checksum, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> core::result::Result - where - E: serde::de::Error, - { - match value { - "checksum" => Ok(GeneratedField::Checksum), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MsgStoreCodeResponse; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.lightclients.wasm.v1.MsgStoreCodeResponse") - } - - fn visit_map(self, mut map_: V) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut checksum__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Checksum => { - if checksum__.is_some() { - return Err(serde::de::Error::duplicate_field("checksum")); - } - checksum__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; - } - } - } - Ok(MsgStoreCodeResponse { - checksum: checksum__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("ibc.lightclients.wasm.v1.MsgStoreCodeResponse", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for QueryChecksumsRequest { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> core::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.QueryChecksumsRequest", len)?; - if let Some(v) = self.pagination.as_ref() { - struct_ser.serialize_field("pagination", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for QueryChecksumsRequest { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "pagination", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Pagination, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> core::result::Result - where - E: serde::de::Error, - { - match value { - "pagination" => Ok(GeneratedField::Pagination), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryChecksumsRequest; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.lightclients.wasm.v1.QueryChecksumsRequest") - } - - fn visit_map(self, mut map_: V) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut pagination__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Pagination => { - if pagination__.is_some() { - return Err(serde::de::Error::duplicate_field("pagination")); - } - pagination__ = map_.next_value()?; - } - } - } - Ok(QueryChecksumsRequest { - pagination: pagination__, - }) - } - } - deserializer.deserialize_struct("ibc.lightclients.wasm.v1.QueryChecksumsRequest", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for QueryChecksumsResponse { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> core::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if true { - len += 1; - } - if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.QueryChecksumsResponse", len)?; - if true { - struct_ser.serialize_field("checksums", &self.checksums)?; - } - if let Some(v) = self.pagination.as_ref() { - struct_ser.serialize_field("pagination", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for QueryChecksumsResponse { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "checksums", - "pagination", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Checksums, - Pagination, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> core::result::Result - where - E: serde::de::Error, - { - match value { - "checksums" => Ok(GeneratedField::Checksums), - "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 = QueryChecksumsResponse; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.lightclients.wasm.v1.QueryChecksumsResponse") - } - - fn visit_map(self, mut map_: V) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut checksums__ = None; - let mut pagination__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Checksums => { - if checksums__.is_some() { - return Err(serde::de::Error::duplicate_field("checksums")); - } - checksums__ = Some(map_.next_value()?); - } - GeneratedField::Pagination => { - if pagination__.is_some() { - return Err(serde::de::Error::duplicate_field("pagination")); - } - pagination__ = map_.next_value()?; - } - } - } - Ok(QueryChecksumsResponse { - checksums: checksums__.unwrap_or_default(), - pagination: pagination__, - }) - } - } - deserializer.deserialize_struct("ibc.lightclients.wasm.v1.QueryChecksumsResponse", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for QueryCodeRequest { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> core::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.QueryCodeRequest", len)?; - if true { - struct_ser.serialize_field("checksum", &self.checksum)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for QueryCodeRequest { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "checksum", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Checksum, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> core::result::Result - where - E: serde::de::Error, - { - match value { - "checksum" => Ok(GeneratedField::Checksum), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryCodeRequest; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.lightclients.wasm.v1.QueryCodeRequest") - } - - fn visit_map(self, mut map_: V) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut checksum__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Checksum => { - if checksum__.is_some() { - return Err(serde::de::Error::duplicate_field("checksum")); - } - checksum__ = Some(map_.next_value()?); - } - } - } - Ok(QueryCodeRequest { - checksum: checksum__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("ibc.lightclients.wasm.v1.QueryCodeRequest", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for QueryCodeResponse { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> core::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if true { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.QueryCodeResponse", len)?; - if true { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for QueryCodeResponse { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "data", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Data, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> core::result::Result - where - E: serde::de::Error, - { - match value { - "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 = QueryCodeResponse; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct ibc.lightclients.wasm.v1.QueryCodeResponse") - } - - fn visit_map(self, mut map_: V) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut data__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Data => { - if data__.is_some() { - return Err(serde::de::Error::duplicate_field("data")); - } - data__ = - Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; - } - } - } - Ok(QueryCodeResponse { - data: data__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("ibc.lightclients.wasm.v1.QueryCodeResponse", FIELDS, GeneratedVisitor) - } -} diff --git a/src/prost/proto_descriptor.bin b/src/prost/proto_descriptor.bin index e1e93ac386d6ecbc3b90d519fa4116c2f21aa8d8..a785e760ead18d6b4b6a4979f2f22f4b319c2dc3 100644 GIT binary patch delta 34040 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 A&;S4c delta 23665 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 From 0a12acb54fc7eeb2905ebae854f4c14bea703767 Mon Sep 17 00:00:00 2001 From: Luca Joss Date: Wed, 7 Feb 2024 15:13:55 +0100 Subject: [PATCH 2/3] Add changelog --- .changelog/unreleased/features/192-bump-ibc-go-v8-1-0.md | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 .changelog/unreleased/features/192-bump-ibc-go-v8-1-0.md diff --git a/.changelog/unreleased/features/192-bump-ibc-go-v8-1-0.md b/.changelog/unreleased/features/192-bump-ibc-go-v8-1-0.md new file mode 100644 index 0000000..92f654f --- /dev/null +++ b/.changelog/unreleased/features/192-bump-ibc-go-v8-1-0.md @@ -0,0 +1,2 @@ +- Bump ibc-go to v8.1.0 ([\#192](https://github.com/cosmos/ibc-proto- + rs/pull/192)) \ No newline at end of file From 1300300d5c3cc19fabb0c87c0dc2386249204006 Mon Sep 17 00:00:00 2001 From: Luca Joss Date: Wed, 7 Feb 2024 15:29:57 +0100 Subject: [PATCH 3/3] Remove wasm client proto related mod --- src/lib.rs | 7 ------- 1 file changed, 7 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 5f2843a..bc37dda 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -375,13 +375,6 @@ pub mod ibc { include_proto!("ibc.lightclients.tendermint.v1.serde.rs"); } } - pub mod wasm { - pub mod v1 { - include_proto!("ibc.lightclients.wasm.v1.rs"); - #[cfg(feature = "serde")] - include_proto!("ibc.lightclients.wasm.v1.serde.rs"); - } - } } pub mod mock { include_proto!("ibc.mock.rs");